{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "a1c59f8a"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch import optim\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "from sklearn.manifold import TSNE\n",
    "from sklearn.decomposition import PCA\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "ahJcCrzPQl-k"
   },
   "outputs": [],
   "source": [
    "def extract_time (data):\n",
    "  \"\"\"Returns Maximum sequence length and each sequence length.\n",
    "  \n",
    "  Args:\n",
    "    - data: original data\n",
    "    \n",
    "  Returns:\n",
    "    - time: extracted time information\n",
    "    - max_seq_len: maximum sequence length\n",
    "  \"\"\"\n",
    "  time = list()\n",
    "  max_seq_len = 0\n",
    "  for i in range(len(data)):\n",
    "    max_seq_len = max(max_seq_len, len(data[i][:,0]))\n",
    "    time.append(len(data[i][:,0]))\n",
    "    \n",
    "  return time, max_seq_len\n",
    "\n",
    "def random_generator (batch_size, z_dim, T_mb, max_seq_len):\n",
    "  \"\"\"Random vector generation.\n",
    "  \n",
    "  Args:\n",
    "    - batch_size: size of the random vector\n",
    "    - z_dim: dimension of random vector\n",
    "    - T_mb: time information for the random vector\n",
    "    - max_seq_len: maximum sequence length\n",
    "    \n",
    "  Returns:\n",
    "    - Z_mb: generated random vector\n",
    "  \"\"\"\n",
    "  Z_mb = list()\n",
    "  for i in range(batch_size):\n",
    "    temp = np.zeros([max_seq_len, z_dim])\n",
    "    temp_Z = np.random.uniform(0., 10, [T_mb[i], z_dim])\n",
    "    temp[:T_mb[i],:] = temp_Z\n",
    "    Z_mb.append(temp_Z)\n",
    "  return Z_mb\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "KsYQ9_Y1Qe70"
   },
   "outputs": [],
   "source": [
    "def MinMaxScaler(data):\n",
    "  \"\"\"Min Max normalizer.\n",
    "  \n",
    "  Args:\n",
    "    - data: original data\n",
    "  \n",
    "  Returns:\n",
    "    - norm_data: normalized data\n",
    "  \"\"\"\n",
    "  numerator = data - np.min(data, 0)\n",
    "  denominator = np.max(data, 0) - np.min(data, 0)\n",
    "  norm_data = numerator / (denominator + 1e-7)\n",
    "  return norm_data\n",
    "\n",
    "\n",
    "def sine_data_generation (no, seq_len, dim):\n",
    "  \"\"\"Sine data generation.\n",
    "  \n",
    "  Args:\n",
    "    - no: the number of samples\n",
    "    - seq_len: sequence length of the time-series\n",
    "    - dim: feature dimensions\n",
    "    \n",
    "  Returns:\n",
    "    - data: generated data\n",
    "  \"\"\"  \n",
    "  # Initialize the output\n",
    "  data = list()\n",
    "\n",
    "  # Generate sine data\n",
    "  for i in range(no):      \n",
    "    # Initialize each time-series\n",
    "    temp = list()\n",
    "    # For each feature\n",
    "    for k in range(dim):\n",
    "      # Randomly drawn frequency and phase\n",
    "      freq = np.random.uniform(0, 0.1)            \n",
    "      phase = np.random.uniform(0, 0.1)\n",
    "          \n",
    "      # Generate sine signal based on the drawn frequency and phase\n",
    "      temp_data = [np.sin(freq * j + phase) for j in range(seq_len)] \n",
    "      temp.append(temp_data)\n",
    "        \n",
    "    # Align row/column\n",
    "    temp = np.transpose(np.asarray(temp))        \n",
    "    # Normalize to [0,1]\n",
    "    temp = (temp + 1)*0.5\n",
    "    # Stack the generated data\n",
    "    data.append(temp)\n",
    "                \n",
    "  return data\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4e849290"
   },
   "source": [
    "Define Class for Module Construction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "294d9abe"
   },
   "outputs": [],
   "source": [
    "class Time_GAN_module(nn.Module):\n",
    "    \"\"\"\n",
    "    Class from which a module of the Time GAN Architecture can be constructed, \n",
    "    consisting of a n_layer stacked RNN layers and a fully connected layer\n",
    "    \n",
    "    input_size = dim of data (depending if module operates on latent or non-latent space)\n",
    "    \"\"\"\n",
    "    def __init__(self, input_size, output_size, hidden_dim, n_layers, activation=torch.sigmoid):\n",
    "        super(Time_GAN_module, self).__init__()\n",
    "\n",
    "        # Parameters\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.n_layers = n_layers\n",
    "        self.sigma = activation\n",
    "\n",
    "        #Defining the layers\n",
    "        # RNN Layer\n",
    "        self.rnn = nn.GRU(input_size, hidden_dim, n_layers, batch_first=True)   \n",
    "        # Fully connected layer\n",
    "        self.fc = nn.Linear(hidden_dim, output_size)\n",
    "        \n",
    "    def forward(self, x):\n",
    "    \n",
    "            batch_size = x.size(0)\n",
    "\n",
    "            # Initializing hidden state for first input using method defined below\n",
    "            hidden = self.init_hidden(batch_size)\n",
    "\n",
    "            # Passing in the input and hidden state into the model and obtaining outputs\n",
    "            out, hidden = self.rnn(x, hidden)\n",
    "        \n",
    "            # Reshaping the outputs such that it can be fit into the fully connected layer\n",
    "            out = out.contiguous().view(-1, self.hidden_dim)\n",
    "            out = self.fc(out)\n",
    "            \n",
    "            if self.sigma == nn.Identity:\n",
    "                idendity = nn.Identity()\n",
    "                return idendity(out)\n",
    "                \n",
    "            out = self.sigma(out)\n",
    "            \n",
    "            # HIDDEN STATES WERDEN IN DER PAPER IMPLEMENTIERUNG AUCH COMPUTED, ALLERDINGS NICHT BENUTZT?\n",
    "            \n",
    "            return out, hidden\n",
    "    \n",
    "    def init_hidden(self, batch_size):\n",
    "        # This method generates the first hidden state of zeros which we'll use in the forward pass\n",
    "        # We'll send the tensor holding the hidden state to the device we specified earlier as well\n",
    "        hidden = torch.zeros(self.n_layers, batch_size, self.hidden_dim)\n",
    "        return hidden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "65ad1d5e"
   },
   "source": [
    "Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "6a2e3f85"
   },
   "outputs": [],
   "source": [
    "input_size = 5 # sequence length = number of features\n",
    "output_size = 20\n",
    "hidden_dim = 40\n",
    "n_layers = 1\n",
    "gamma = 1\n",
    "\n",
    "no, seq_len, dim = 12800, 24, 1\n",
    "\n",
    "batch_size = 128\n",
    "epoch = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "b35b74eb"
   },
   "source": [
    "Data Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "2373fb48",
    "outputId": "00332056-d68c-4eb0-e28c-a2df411f706f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([12800, 24, 1])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = sine_data_generation(no, seq_len, dim)\n",
    "data = MinMaxScaler(data)\n",
    "data = torch.Tensor(data)\n",
    "data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "90e9892c"
   },
   "source": [
    "Create Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "a05ad143"
   },
   "source": [
    "Data Loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "9e2cd6ad"
   },
   "outputs": [],
   "source": [
    "from torch.utils.data import DataLoader\n",
    "\n",
    "loader = DataLoader(data, batch_size, shuffle=False)\n",
    "\n",
    "random_data = random_generator(batch_size=batch_size, z_dim=dim, \n",
    "                                       T_mb=extract_time(data)[0], max_seq_len=extract_time(data)[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "GFKdBugWo9OM"
   },
   "outputs": [],
   "source": [
    "def TimeGAN(data, parameters):\n",
    "  hidden_dim = parameters[\"hidden_dim\"]\n",
    "  num_layers = parameters[\"num_layers\"]\n",
    "  iterations = parameters[\"iterations\"]\n",
    "  batch_size = parameters[\"batch_size\"]\n",
    "  module = parameters[\"module\"]\n",
    "  epoch = parameters[\"epoch\"]\n",
    "  no, seq_len, dim = np.asarray(data).shape\n",
    "  z_dim = dim\n",
    "  gamma = 1\n",
    "\n",
    "  checkpoints = {}\n",
    "\n",
    "  Embedder = Time_GAN_module(input_size=z_dim, output_size=hidden_dim, hidden_dim=hidden_dim, n_layers=num_layers)\n",
    "  Recovery = Time_GAN_module(input_size=hidden_dim, output_size=dim, hidden_dim=hidden_dim, n_layers=n_layers)\n",
    "  Generator = Time_GAN_module(input_size=dim, output_size=hidden_dim, hidden_dim=hidden_dim, n_layers=n_layers)\n",
    "  Supervisor = Time_GAN_module(input_size=hidden_dim, output_size=hidden_dim, hidden_dim=hidden_dim, n_layers=n_layers)\n",
    "  Discriminator = Time_GAN_module(input_size=hidden_dim, output_size=1, hidden_dim=hidden_dim, n_layers=n_layers, activation=nn.Identity)\n",
    "\n",
    "  embedder_optimizer = optim.Adam(Embedder.parameters(), lr=0.0035)\n",
    "  recovery_optimizer = optim.Adam(Recovery.parameters(), lr=0.01)\n",
    "  supervisor_optimizer = optim.Adam(Recovery.parameters(), lr=0.001)\n",
    "  discriminator_optimizer = optim.Adam(Discriminator.parameters(), lr=0.01)\n",
    "  generator_optimizer = optim.Adam(Generator.parameters(), lr=0.01)\n",
    "  \n",
    "\n",
    "  binary_cross_entropy_loss = nn.BCEWithLogitsLoss()\n",
    "  MSE_loss = nn.MSELoss()\n",
    "  \n",
    "  # Embedding Network Training\n",
    "  print('Start Embedding Network Training')\n",
    "  for e in range(epoch): \n",
    "    for batch_index, X in enumerate(loader):\n",
    "                \n",
    "        H, _ = Embedder(X.float())\n",
    "        H = torch.reshape(H, (batch_size, seq_len, hidden_dim))\n",
    "\n",
    "        X_tilde, _ = Recovery(H)\n",
    "        X_tilde = torch.reshape(X_tilde, (batch_size, seq_len, dim))\n",
    "\n",
    "        E_loss0 = 10 * torch.sqrt(MSE_loss(X, X_tilde))  \n",
    "\n",
    "        Embedder.zero_grad()\n",
    "        Recovery.zero_grad()\n",
    "\n",
    "        E_loss0.backward(retain_graph=True)\n",
    "\n",
    "        embedder_optimizer.step()\n",
    "        recovery_optimizer.step()\n",
    "\n",
    "        if e in range(1,epoch) and batch_index == 0:\n",
    "            print('step: '+ str(e) + '/' + str(epoch) + ', e_loss: ' + str(np.sqrt(E_loss0.detach().numpy())))\n",
    "\n",
    "  print('Finish Embedding Network Training')\n",
    "\n",
    "  # Training only with supervised loss\n",
    "  print('Start Training with Supervised Loss Only')\n",
    "  for e in range(epoch): \n",
    "    for batch_index, X in enumerate(loader):\n",
    "\n",
    "        H, _ = Embedder(X.float())\n",
    "        H = torch.reshape(H, (batch_size, seq_len, hidden_dim))\n",
    "\n",
    "        H_hat_supervise, _ = Supervisor(H)\n",
    "        H_hat_supervise = torch.reshape(H_hat_supervise, (batch_size, seq_len, hidden_dim))  \n",
    "\n",
    "        G_loss_S = MSE_loss(H[:,1:,:], H_hat_supervise[:,:-1,:])\n",
    "\n",
    "\n",
    "        Embedder.zero_grad()\n",
    "        Supervisor.zero_grad()\n",
    "\n",
    "        G_loss_S.backward(retain_graph=True)\n",
    "\n",
    "        embedder_optimizer.step()\n",
    "        supervisor_optimizer.step()\n",
    "\n",
    "        if e in range(1,epoch) and batch_index == 0:\n",
    "            print('step: '+ str(e) + '/' + str(epoch) + ', s_loss: ' + str(np.sqrt(G_loss_S.detach().numpy())))\n",
    "\n",
    "  print('Finish Training with Supervised Loss Only')\n",
    "  # Joint Training\n",
    "  \n",
    "\n",
    "  print('Start Joint Training')\n",
    "  for itt in range(epoch):\n",
    "    for kk in range(2):\n",
    "      X = next(iter(loader))\n",
    "      random_data #= random_generator(batch_size=batch_size, z_dim=dim, \n",
    "                                       #T_mb=extract_time(data)[0], max_seq_len=extract_time(data)[1])\n",
    "        \n",
    "      # Generator Training \n",
    "      ## Train Generator\n",
    "      z = torch.tensor(random_data)\n",
    "      z = z.float()\n",
    "        \n",
    "      e_hat, _ = Generator(z)\n",
    "      e_hat = torch.reshape(e_hat, (batch_size, seq_len, hidden_dim))\n",
    "        \n",
    "      H_hat, _ = Supervisor(e_hat)\n",
    "      H_hat = torch.reshape(H_hat, (batch_size, seq_len, hidden_dim))\n",
    "        \n",
    "      Y_fake = Discriminator(H_hat)\n",
    "      Y_fake = torch.reshape(Y_fake, (batch_size, seq_len, 1))\n",
    "        \n",
    "      x_hat, _ = Recovery(H_hat)\n",
    "      x_hat = torch.reshape(x_hat, (batch_size, seq_len, dim))\n",
    "        \n",
    "      H, _ = Embedder(X.float())\n",
    "      H = torch.reshape(H, (batch_size, seq_len, hidden_dim))\n",
    "\n",
    "      H_hat_supervise, _ = Supervisor(H)\n",
    "      H_hat_supervise = torch.reshape(H_hat_supervise, (batch_size, seq_len, hidden_dim))\n",
    "\n",
    "      Generator.zero_grad()\n",
    "      Supervisor.zero_grad()\n",
    "      Discriminator.zero_grad()\n",
    "      Recovery.zero_grad()\n",
    "\n",
    "      # line 267 of original implementation: \n",
    "      # G_loss_U, G_loss_S, G_loss_V\n",
    "      G_loss_S = MSE_loss(H[:,1:,:], H_hat_supervise[:,:-1,:])\n",
    "      binary_cross_entropy_loss = nn.BCEWithLogitsLoss()\n",
    "      # logits first, then targets\n",
    "      # D_loss_real(Y_real, torch.ones_like(Y_real))\n",
    "      G_loss_U = binary_cross_entropy_loss(Y_fake, torch.ones_like(Y_fake))\n",
    "        \n",
    "      G_loss_V1 = torch.mean(torch.abs((torch.std(x_hat, [0], unbiased = False)) + 1e-6 - (torch.std(X, [0]) + 1e-6)))\n",
    "      G_loss_V2 = torch.mean(torch.abs((torch.mean(x_hat, [0]) - (torch.mean(X, [0])))))\n",
    "      G_loss_V = G_loss_V1 + G_loss_V2\n",
    "        \n",
    "      # doing a backward step for each loss should result in gradients accumulating \n",
    "      # so we should be able to optimize them jointly\n",
    "      G_loss_S.backward(retain_graph=True)#\n",
    "      G_loss_U.backward(retain_graph=True)\n",
    "      G_loss_V.backward(retain_graph=True)#\n",
    "\n",
    "\n",
    "      generator_optimizer.step()\n",
    "      supervisor_optimizer.step()\n",
    "      discriminator_optimizer.step()\n",
    "      # Train Embedder \n",
    "      ## line 270: we only optimize E_loss_T0\n",
    "      ## E_loss_T0 = just mse of x and x_tilde\n",
    "      # but it calls E_solver which optimizes E_loss, which is a sum of \n",
    "      # E_loss0 and 0.1* G_loss_S\n",
    "      MSE_loss = nn.MSELoss()\n",
    "        \n",
    "      H, _ = Embedder(X.float())\n",
    "      H = torch.reshape(H, (batch_size, seq_len, hidden_dim))\n",
    "\n",
    "      X_tilde, _ = Recovery(H)\n",
    "      X_tilde = torch.reshape(X_tilde, (batch_size, seq_len, dim))\n",
    "\n",
    "      E_loss_T0 = MSE_loss(X, X_tilde)\n",
    "      E_loss0 = 10 * torch.sqrt(MSE_loss(X, X_tilde))  \n",
    "        \n",
    "      H_hat_supervise, _ = Supervisor(H)\n",
    "      H_hat_supervise = torch.reshape(H_hat_supervise, (batch_size, seq_len, hidden_dim))  \n",
    "\n",
    "      G_loss_S = MSE_loss(H[:,1:,:], H_hat_supervise[:,:-1,:])\n",
    "      E_loss = E_loss0  + 0.1 * G_loss_S\n",
    "        \n",
    "      G_loss_S.backward(retain_graph=True)\n",
    "      E_loss_T0.backward()\n",
    "        \n",
    "      Embedder.zero_grad()\n",
    "      Recovery.zero_grad()\n",
    "      Supervisor.zero_grad()\n",
    "        \n",
    "      embedder_optimizer.step()\n",
    "      recovery_optimizer.step()\n",
    "      supervisor_optimizer.step()\n",
    "    # train Discriminator\n",
    "    for batch_index, X in enumerate(loader):\n",
    "      random_data #= random_generator(batch_size=batch_size, z_dim=dim, \n",
    "                                       #T_mb=extract_time(data)[0], max_seq_len=extract_time(data)[1])\n",
    "      \n",
    "      z = torch.tensor(random_data)\n",
    "      z = z.float()\n",
    "\n",
    "      H, _ = Embedder(X)\n",
    "      H = torch.reshape(H, (batch_size, seq_len, hidden_dim))\n",
    "\n",
    "      Y_real = Discriminator(H)\n",
    "      Y_real = torch.reshape(Y_real, (batch_size, seq_len, 1))\n",
    "      \n",
    "      e_hat, _ = Generator(z)\n",
    "      e_hat = torch.reshape(e_hat, (batch_size, seq_len, hidden_dim))\n",
    "\n",
    "      Y_fake_e = Discriminator(e_hat)\n",
    "      Y_fake_e = torch.reshape(Y_fake_e, (batch_size, seq_len, 1))\n",
    "        \n",
    "      H_hat, _ = Supervisor(e_hat)\n",
    "      H_hat = torch.reshape(H_hat, (batch_size, seq_len, hidden_dim))\n",
    "        \n",
    "      Y_fake = Discriminator(H_hat)\n",
    "      Y_fake = torch.reshape(Y_fake, (batch_size, seq_len, 1))\n",
    "        \n",
    "      x_hat, _ = Recovery(H_hat)\n",
    "      x_hat = torch.reshape(x_hat, (batch_size, seq_len, dim))\n",
    "\n",
    "      Generator.zero_grad()\n",
    "      Supervisor.zero_grad()\n",
    "      Discriminator.zero_grad()\n",
    "      Recovery.zero_grad()\n",
    "      Embedder.zero_grad()\n",
    "\n",
    "      # logits first, then targets\n",
    "      # D_loss_real(Y_real, torch.ones_like(Y_real))\n",
    "      D_loss_real = nn.BCEWithLogitsLoss()\n",
    "      DLR = D_loss_real(Y_real, torch.ones_like(Y_real))\n",
    "\n",
    "      D_loss_fake = nn.BCEWithLogitsLoss()\n",
    "      DLF = D_loss_fake(Y_fake, torch.zeros_like(Y_fake))\n",
    "\n",
    "      D_loss_fake_e = nn.BCEWithLogitsLoss()\n",
    "      DLF_e = D_loss_fake_e(Y_fake_e, torch.zeros_like(Y_fake_e))\n",
    "\n",
    "      D_loss = DLR + DLF + gamma * DLF_e\n",
    "\n",
    "      # check discriminator loss before updating\n",
    "      check_d_loss = D_loss\n",
    "      if (check_d_loss > 0.15):\n",
    "        D_loss.backward(retain_graph=True)\n",
    "        discriminator_optimizer.step()        \n",
    "        \n",
    "      H, _ = Embedder(X.float())\n",
    "      H = torch.reshape(H, (batch_size, seq_len, hidden_dim)) \n",
    "        \n",
    "      X_tilde, _ = Recovery(H)\n",
    "      X_tilde = torch.reshape(X_tilde, (batch_size, seq_len, dim))\n",
    "\n",
    "      \n",
    "      z = torch.tensor(random_data)\n",
    "      z = z.float()\n",
    "        \n",
    "      e_hat, _ = Generator(z)\n",
    "      e_hat = torch.reshape(e_hat, (batch_size, seq_len, hidden_dim))\n",
    "        \n",
    "      H_hat, _ = Supervisor(e_hat)\n",
    "      H_hat = torch.reshape(H_hat, (batch_size, seq_len, hidden_dim))\n",
    "        \n",
    "      Y_fake = Discriminator(H_hat)\n",
    "      Y_fake = torch.reshape(Y_fake, (batch_size, seq_len, 1))\n",
    "        \n",
    "      x_hat, _ = Recovery(H_hat)\n",
    "      x_hat = torch.reshape(x_hat, (batch_size, seq_len, dim))\n",
    "        \n",
    "      H, _ = Embedder(X.float())\n",
    "      H = torch.reshape(H, (batch_size, seq_len, hidden_dim))\n",
    "\n",
    "      H_hat_supervise, _ = Supervisor(H)\n",
    "      H_hat_supervise = torch.reshape(H_hat_supervise, (batch_size, seq_len, hidden_dim))\n",
    "\n",
    "      G_loss_S = MSE_loss(H[:,1:,:], H_hat_supervise[:,:-1,:])\n",
    "      binary_cross_entropy_loss = nn.BCEWithLogitsLoss()\n",
    "      # logits first then targets\n",
    "      G_loss_U = binary_cross_entropy_loss(Y_fake, torch.ones_like(Y_fake))\n",
    "        \n",
    "      G_loss_V1 = torch.mean(torch.abs((torch.std(x_hat, [0], unbiased = False)) + 1e-6 - (torch.std(X, [0]) + 1e-6)))\n",
    "      G_loss_V2 = torch.mean(torch.abs((torch.mean(x_hat, [0]) - (torch.mean(X, [0])))))\n",
    "      G_loss_V = G_loss_V1 + G_loss_V2\n",
    "    \n",
    "      E_loss_T0 = MSE_loss(X, X_tilde)\n",
    "      E_loss0 = 10 * torch.sqrt(MSE_loss(X, X_tilde))  \n",
    "      E_loss = E_loss0  + 0.1 * G_loss_S\n",
    "        \n",
    "      # doing a backward step for each loss should result in gradients accumulating \n",
    "      # so we should be able to optimize them jointly\n",
    "      G_loss_S.backward(retain_graph=True)#\n",
    "      G_loss_U.backward(retain_graph=True)\n",
    "      G_loss_V.backward(retain_graph=True)#\n",
    "      E_loss.backward()\n",
    "\n",
    "      generator_optimizer.step()\n",
    "      supervisor_optimizer.step()\n",
    "      embedder_optimizer.step()\n",
    "      recovery_optimizer.step()\n",
    "            \n",
    "      print('step: '+ str(itt) + '/' + str(epoch) + \n",
    "            ', D_loss: ' + str(D_loss.detach().numpy()) +\n",
    "            ', G_loss_U: ' + str(G_loss_U.detach().numpy()) + \n",
    "            ', G_loss_S: ' + str(G_loss_S.detach().numpy()) + \n",
    "            ', E_loss_t0: ' + str(np.sqrt(E_loss0.detach().numpy())))\n",
    "         \n",
    "\n",
    "      \n",
    "      random_test = random_generator(1, dim, extract_time(data)[0], extract_time(data)[1])        \n",
    "      test_sample = Generator(torch.tensor(random_generator(1, dim, extract_time(data)[0], extract_time(data)[1])).float())[0]      \n",
    "      test_sample = torch.reshape(test_sample, (1, seq_len, hidden_dim))\n",
    "      test_recovery = Recovery(test_sample)\n",
    "      test_recovery = torch.reshape(test_recovery[0], (1, seq_len, dim))\n",
    "      fig, ax = plt.subplots()\n",
    "      ax1 = plt.plot(test_recovery[0].detach().numpy())\n",
    "      plt.show()\n",
    "      \n",
    "      if itt % 2:\n",
    "        checkpoints[itt] = [Generator.state_dict(), Discriminator.state_dict(), Embedder.state_dict(), Recovery.state_dict,\n",
    "                    Supervisor.state_dict()]\n",
    "             \n",
    "  print('Finish Joint Training')\n",
    "        \n",
    "  random_test = random_generator(12800, dim, extract_time(data)[0], extract_time(data)[1])\n",
    "  test_sample = Generator(torch.tensor(random_generator(12800, dim, extract_time(data)[0], extract_time(data)[1])).float())[0]\n",
    "  test_sample = torch.reshape(test, (12800, seq_len, hidden_dim))\n",
    "  test_recovery = Recovery(test_sample)\n",
    "  test_recovery = torch.reshape(test_recovery[0], (12800, seq_len, dim))\n",
    "  visualization(data, test_recovery.detach().numpy(), 'tsne')\n",
    "  visualization(data, test_recovery.detach().numpy(), 'pca')\n",
    "  \n",
    "    \n",
    "    \n",
    "  return Generator, Embedder, Supervisor, Recovery, Discriminator, test, test_recovery, checkpoints\n",
    "  \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "YPbbUH0dJqjt"
   },
   "outputs": [],
   "source": [
    "parameters = dict()\n",
    "parameters['module'] = 'gru' \n",
    "parameters['hidden_dim'] = 40\n",
    "parameters['num_layers'] = 1\n",
    "parameters['iterations'] = 10000\n",
    "parameters['batch_size'] = 128\n",
    "parameters['epoch'] = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "9rnug7qqmddM",
    "outputId": "aacf2bb0-7f70-496a-d98f-0316b540c67a",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start Embedding Network Training\n",
      "step: 1/2, e_loss: 0.47473982\n",
      "Finish Embedding Network Training\n",
      "Start Training with Supervised Loss Only\n",
      "step: 1/2, s_loss: 0.1014306\n",
      "Finish Training with Supervised Loss Only\n",
      "Start Joint Training\n",
      "step: 0/2, D_loss: 3.4109573, G_loss_U: 0.2933319, G_loss_S: 0.0066051786, E_loss_t0: 2.2793045\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 2.990453, G_loss_U: 0.40209842, G_loss_S: 0.006284239, E_loss_t0: 2.165688\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 2.5270872, G_loss_U: 0.53227824, G_loss_S: 0.0062683127, E_loss_t0: 2.1476083\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 2.2035565, G_loss_U: 0.66739106, G_loss_S: 0.006295599, E_loss_t0: 2.2121317\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 2.0160606, G_loss_U: 0.7987168, G_loss_S: 0.0061779856, E_loss_t0: 2.2134256\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.9205184, G_loss_U: 0.92068243, G_loss_S: 0.006547418, E_loss_t0: 2.2095122\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.8785675, G_loss_U: 1.0273427, G_loss_S: 0.0060302736, E_loss_t0: 2.1589549\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.8644166, G_loss_U: 1.1121227, G_loss_S: 0.005840355, E_loss_t0: 2.2147005\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.8603892, G_loss_U: 1.1691041, G_loss_S: 0.0061901854, E_loss_t0: 2.1987028\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.857754, G_loss_U: 1.1947923, G_loss_S: 0.00582797, E_loss_t0: 2.2681758\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.8475534, G_loss_U: 1.1890877, G_loss_S: 0.006415325, E_loss_t0: 2.222678\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.8283981, G_loss_U: 1.1550764, G_loss_S: 0.0062972195, E_loss_t0: 2.1383293\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD4CAYAAAAHHSreAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAfAklEQVR4nO3de3Bc5Z3m8e9P3erWXcK62IBvXEyISBnDeGAnyaxhCMRAahnIVIAN2exkE6Z2YWvDDlMLm1Q2RS1FqM0kWzvLUkV2nctWgKTIMOOq9cYmXMpkIAzm5iAIxHjxFbXkm1oXd0vd/ds/+pXUlmSrZctqS+f5VHX16fdc9J6u1nnOed9zMXdHRESkVFWlKyAiImcehYOIiEyicBARkUkUDiIiMonCQUREJolXugKzoa2tzVeuXFnpaoiIzCuvvfbaAXdvn2rcggiHlStXsm3btkpXQ0RkXjGzXccbp2YlERGZROEgIiKTlBUOZrbezN4zsx1mdt8U41eY2bNmtt3MXjCzpSXjHjazt8Pr1pLyPzGz10P5j80sHsrNzP5b+Fvbzezy2VhREREp37ThYGYx4BHgeqATuN3MOidM9l3gJ+6+GngAeCjMeyNwObAGuBK418yazKwK+DFwm7t/AtgFfDks63pgVXjdCTx6KisoIiIzV86RwxXADnff6e7DwJPATROm6QSeC8PPl4zvBLa6e87dB4HtwHqgFRh29/fDdM8Anw/DN1EMGnf33wAtZnb2SaybiIicpHLC4VxgT8nnvaGs1FvALWH4ZqDRzFpD+XozqzOzNuBqYBlwAIib2dowz5+F8nL/HmZ2p5ltM7Ntvb29ZayGiIiUa7Y6pO8F1pnZG8A6YB+Qd/ctwCbgJeAJ4OVQ7sBtwPfN7B+BfiA/kz/o7o+5+1p3X9vePuVpuiIicpLKuc5hH+N79QBLQ9kYd99POHIwswbg8+5+JIx7EHgwjHsceD+Uvwz8cSi/Drio3L8nIrLQuDsjeefoSJ7MSJ6h4TxHh/PHfh7JkwnvR0PZNRd3cOmyllmvTznh8CqwyszOo7iRvg3456UThCajQ+5eAO4HNoTyGNDi7gfNbDWwGtgSxnW4e4+ZJYH/QAgQYCNwt5k9SbETu8/dPzrF9RQRKYu7k80VyJRsgI8O54/5nBkZ33CXfh4KG+9MLs9wzhnJF8Zew7kCw/mSslyB4VA+kneG8wXyhZk/X6ejMVmZcHD3nJndDWwGYsAGd+8ysweAbe6+EbgKeMjMHNgK3BVmrwZeNDOANHCHu+fCuL8ys89RbNp61N1HO7Q3ATcAO4Ah4M9PfTVFZKHJ5QsMDucZGs4xmM0zmM0xOJxjKJtnMJQNDecYyOYYGi6OP1qy1z02XLJ3Pjo80220GdRVx6hNxKipjpGMV5GIx0jEq0jEjOpYFXWJONWxKpLxKqpDWXW8ikSsikQoq60uzl+XiFObqBr7XFtSVvo5Ga+iqspOy/drC+FJcGvXrnXdPkPkzJTLF+g7OjL2OnJ0hPTREY4MFT/3Z0bI5gpkRwpkcnmyIwWyufzY3ns2Vwiv4rjMSJ5MrrjHXa6a6uLGuS4xumENG93weex9dFzJ54nT1IRpSj8n41WEneB5xcxec/e1U41bEPdWEpHTJ19wBjI50pkR0pkR+jM5+jM50mHDns7k6A/lYwEwNB4GA9ncCZdfU13cG66Jx0hWF/esk/HY2Ab9rLqqUF4sS8aLG+O6RJz6ZIz6ZHGj35CMH1NWn4hTl4xRn4gTO0171wuZwkFkAXMvdnD2hw1439HcpA16cSOfG9vwj34enW66jTtAbXWMxpo4TbXVtNRWc3ZzDRef3UhzbTUttQmaa+M01xWHm2qraamrprm2mqaaahJx3cXnTKRwEDmDuTt9R0fo7c/SO5Dl4MAwA9kcg9ni3vtANsdAeO8P5WOfM8W99unaz+NVNrZhb6yJ01RTzcq2OhprihvvieOaauLFcbXF98aaYlu6LCwKB5E5li84/ZkRDg0Oc2BguLjh78+MDw9kOTCQpbe/+D6SP/7WvT4Ro6EmTkMyTkNNNY3JOO0NyfGyZJz6ZHxsQz66YW8e+1xNTfX8bC+X00vhIHKSRvfqU+kshwaH6Ts6PKnNfWLn65GhYfqzOaY6DyRWZbTWJ2hvTNLemOSixY20NyZpayh+bm9I0tqQoDFs+OsT8dN2poqIwkFkgtKNfiqdoae/+N4b3kfLevqzxz1jJl5ltNRVj7XBtzUkuKC9npa6xFjZWfXVtDfUhABIcFZdQht7OWMoHCQSCgXnyNERDoQmmwMDwxzoz3JwMMuB/mEODmbpDWW9A1Nv9Btr4ixuqmFxU5I/XLmIjqYkixtr6GhKsqg+Uex4rStu+OsSMTXVyLymcJB5LZvL05PO0tOfIZXO0pPOkCrZ0z8wMMyBgWKzz1RXn8aqjEX1Cdoainvv57fV09GYpKOpho7G5FgYdDTWUJuIVWANRSpD4SBnHHdncDg/1iFb7LAdbdIpBkFPOkuqP8ORoZFJ81fHjI7GGtoak5zbUsulS5tpC+31o+/F9vskLbXVasoRmYLCQeZMoeB0pzN81Jc5dsM/kB1rzhkty4xMbtaJVxkdjUnam2pY0VrHFectGtur72gq7uV3NCbVdi8yCxQOMqty+QL7j2T48OAguw4O8uHBobH33YeGpmzLX1Rf3JNva0zwB8vPOuYMnbEzdRqTLNJGX2TOKBxkxrK5PHsOHWX3oUF2HRxi18GhEAZD7Dk0RK6kbb+muooVi+o5v62eP7m4gxWtdZzTXDu+wa9P6AIqkTOQwkGm1Dc0wq6w8d99aIjdB4fYdWiQ3QeH+CidOeY8/fpEjJVt9XSe3cT1n1jCytZ6lrfWsbK12LmrvX2R+UfhEGED2Rwf9AzwQe8AO3sH+fDgILsPFY8E+o4e29Hb1pBg+aI6rjy/leWL6ljROvqqp7U+odM2RRYYhcMC5+709mfZ0TvABz0D7OgZ4IPeQXb0DNCdzoxNF6syzm2pZUVrHZ9bfTYrWutYvqg+vNdRn9RPRSRK9B+/gKQzI7y15whv70vzQe9oEAzQnxm/q2ZDMs4F7fV88oJWLuho4IL2Bi7saGBFa53a/kVkjMJhnioUnB29A7yx+zCv7zrCG3sO8/uegbG+gI7GJBd2NPCna87lwpIQWNyUVBOQiExL4TBPHBka5o09R3hj9xHe2H2YN3cfoT/cZ7+lrprLlrXwudXncNnyFlYvbaG5trrCNRaR+UzhcIZydzZ3pfjVuyle332Ynb2DAFQZfGxJE/9szTlctvwsLl/ewnlt9ToaEJFZpXA4A730wQEe/r+/4629fSyqT3D58hY+f/lSLlvewqVLW9Q5LCKnnbYyZ5Cu/X08/Mv32Pp+L+c01/Bf/mw1t1y+VM+/FZE5p3A4A+w+OMRfP/Mef//mflrqqvnGDR/nS3+0gppq3QVURCpD4VBBBway/PfndvDTV3YRqzL+zVUX8BfrLlBnsohUnMKhAgayOf7nizv5wdadZHIFvrB2GV//zCoWN9VUumoiIoDCYU4N5wo88Y+7+Zvnfs+BgWGu/8QS7v3sx7igvaHSVRMROYbCYY5s6ermP/+fd9l9aIgrz1vED/7FxVy2/KxKV0tEZEoKhzlwYCDLv/7p61zQXs8P//wPueqidl2XICJnNIXDHPjVOynyBef7t67hknOaK10dEZFp6U5rc2BzVzdLz6ql8+ymSldFRKQsCofTrD8zwj/sOMhnL1mipiQRmTcUDqfZC+/1Mpwv8NlLllS6KiIiZVM4nGabu7pprU/wByt0ZpKIzB8Kh9Mom8vzwnu9XNu5WPdHEpF5ReFwGr204yAD2ZyalERk3lE4nEabu7ppSMb55IWtla6KiMiMlBUOZrbezN4zsx1mdt8U41eY2bNmtt3MXjCzpSXjHjazt8Pr1pLya8zsdTN708x+bWYXTres+SRfcJ55J8VVH2snGdfdVUVkfpk2HMwsBjwCXA90ArebWeeEyb4L/MTdVwMPAA+FeW8ELgfWAFcC95rZ6Mn+jwJfdPc1wOPAN0+0rPnmtV2HOTg4rCYlEZmXyjlyuALY4e473X0YeBK4acI0ncBzYfj5kvGdwFZ3z7n7ILAdWB/GOTAaFM3A/mmWNa9s7uomEaviqo+1V7oqIiIzVk44nAvsKfm8N5SVegu4JQzfDDSaWWsoX29mdWbWBlwNLAvTfRXYZGZ7gS8B35lmWccwszvNbJuZbevt7S1jNeZO8fnP3XzqwlYaa/RsBhGZf2arQ/peYJ2ZvQGsA/YBeXffAmwCXgKeAF4G8mGee4Ab3H0p8EPgeyda1sQ/6O6Puftad1/b3n5m7Z2/81GavYePqklJROatcm68t4/xvX2ApaFsjLvvJ+ztm1kD8Hl3PxLGPQg8GMY9DrxvZu3Ape7+SljEz4BfTres+WJzV4oqg890Lq50VURETko5Rw6vAqvM7DwzSwC3ARtLJzCzNjMbXdb9wIZQHhttEjKz1cBqYAtwGGg2s4vCPNcC755oWfPJlq5u1q5YRFtDstJVERE5KdMeObh7zszuBjYDMWCDu3eZ2QPANnffCFwFPGRmDmwF7gqzVwMvhhvOpYE73D0HYGZfA35hZgWKYfGVMM/xljUv7Do4yO+6+/nmjR+vdFVERE5aWc9zcPdNFPsOSsu+VTL8FPDUFPNlKJ59NNUynwaenqJ8ymXNF5u7ugHU3yAi85qukJ5lm7tSdJ7dxLJFdZWuiojISVM4zKKe/gyv7z6sowYRmfcUDrPomXdSuMNnP6GzlERkflM4zKLNXSlWtNbxscWNla6KiMgpUTjMknRmhJc/OKDHgYrIgqBwmCXP/66Hkbzz2UvUpCQi85/CYZZs7uqmvTHJZcv0OFARmf8UDrMgMzL+ONAqPQ5URBYAhcMs+PXvDzA0nNcprCKyYCgcZsHmrm4aa+L80fl6HKiILAwKh1OUyxf41bsprrm4g0RcX6eILAzamp2iVz88zOGhETUpiciConA4RZu7uknGq1inx4GKyAKicDgF7s4z76T441Xt1CXKusGtiMi8oHA4BW/vS7PvyFFd+CYiC47C4RRs7uomVmV85uMKBxFZWBQOp2BzVzdXrFzEWfWJSldFRGRWKRxO0s7eAX7fM6AmJRFZkBQOJ2lzVwqA63QKq4gsQAqHk/TLrm5WL23mnJbaSldFRGTWKRxOQndfhrf2HNGFbyKyYCkcTsKWd7oB1N8gIguWwuEkbO7q5vz2ei7s0ONARWRhUjjMUN/QCL/ZeUhNSiKyoCkcZui3+/rIF5xPX9hW6aqIiJw2CocZSqUzADpLSUQWNIXDDHWHcFjSVFPhmoiInD4KhxlKpTM01cSpTcQqXRURkdNG4TBD3X0ZljTrqEFEFjaFwwyl+rMsVpOSiCxwCocZSvVlFA4isuApHGYgX3B6B7LqjBaRBU/hMAMHB7LkC85i9TmIyAKncJiB0dNYFzcmK1wTEZHTS+EwA9194RoHHTmIyAKncJiBlC6AE5GIKCsczGy9mb1nZjvM7L4pxq8ws2fNbLuZvWBmS0vGPWxmb4fXrSXl15jZ62b2ppn92swuDOXLzex5M3sjLO+G2VjR2ZBKZ4lVGa0NalYSkYVt2nAwsxjwCHA90AncbmadEyb7LvATd18NPAA8FOa9EbgcWANcCdxrZk1hnkeBL7r7GuBx4Juh/JvAz939MuA24H+c7MrNtu50hvaGJLEqq3RVREROq3KOHK4Adrj7TncfBp4EbpowTSfwXBh+vmR8J7DV3XPuPghsB9aHcQ6MBkUzsH+a8opLpTM6U0lEIqGccDgX2FPyeW8oK/UWcEsYvhloNLPWUL7ezOrMrA24GlgWpvsqsMnM9gJfAr4Tyr8N3BHKNwH/dqpKmdmdZrbNzLb19vaWsRqnrrsvw5ImNSmJyMI3Wx3S9wLrzOwNYB2wD8i7+xaKG/iXgCeAl4F8mOce4AZ3Xwr8EPheKL8d+FEovwH432Y2qZ7u/pi7r3X3te3t7bO0GieWSuvqaBGJhnLCYR/je/sAS0PZGHff7+63hH6Cb4SyI+H9QXdf4+7XAga8b2btwKXu/kpYxM+AT4bhfwX8PMz7MlADVPzJOkeH86QzOYWDiERCOeHwKrDKzM4zswTFTuKNpROYWVvJ3v39wIZQHgvNS5jZamA1sAU4DDSb2UVhnmuBd8PwbuCaMM/HKYbD3LQbnYCe4yAiURKfbgJ3z5nZ3cBmIAZscPcuM3sA2ObuG4GrgIfMzIGtwF1h9mrgRTMDSAN3uHsOwMy+BvzCzAoUw+IrYZ6/BH5gZvdQ7Jz+l+7us7K2p0AXwIlIlEwbDgDuvoli30Fp2bdKhp8CnppivgzFM5amWubTwNNTlL8DfKqces2lnv5w6wx1SItIBOgK6TKNHjmoz0FEokDhUKbudIb6RIzGmupKV0VE5LRTOJSpJ53VBXAiEhkKhzJ1pzMsblQ4iEg0KBzK1N2X0ZlKIhIZCocyFApOT7+ujhaR6FA4lOHw0DAjedd9lUQkMhQOZRh7PKiOHEQkIhQOZRh9ApzOVhKRqFA4lKG7LwvovkoiEh0KhzKk0hnMoL1RfQ4iEg0KhzKk0hla65NUx/R1iUg0aGtXhu50hiXNOmoQkehQOJSh+HhQ9TeISHQoHMrQ05+lQ+EgIhGicJhGNpfn0OCwjhxEJFIUDtPoSes0VhGJHoXDNHQBnIhEkcJhGuO3ztDZSiISHQqHaYw+HlTNSiISJQqHaaTSGZLxKppr9XhQEYkOhcM0Uuksi5tqMLNKV0VEZM4oHKbRndYFcCISPQqHaaTSGZ2pJCKRo3A4AXcPt87QmUoiEi0KhxNIH82RzRX0BDgRiRyFwwno8aAiElUKhxMYDYcl6nMQkYhROJzA6K0zdLaSiESNwuEEUuHqaD0eVESiRuFwAt3pDGfVVVNTHat0VURE5pTC4QRS6Yw6o0UkkhQOJ5BKZ9UZLSKRpHA4ge50hsWNCgcRiR6Fw3GM5AscGMjq1hkiEkllhYOZrTez98xsh5ndN8X4FWb2rJltN7MXzGxpybiHzezt8Lq1pPwaM3vdzN40s1+b2YWh/Puh7E0ze9/MjszCes5Yb38Wd53GKiLRNG04mFkMeAS4HugEbjezzgmTfRf4ibuvBh4AHgrz3ghcDqwBrgTuNbOmMM+jwBfdfQ3wOPBNAHe/x93XhPK/Af72FNbvpKX0BDgRibByjhyuAHa4+053HwaeBG6aME0n8FwYfr5kfCew1d1z7j4IbAfWh3EOjAZFM7B/ir99O/BEOSsy21K6dYaIRFg54XAusKfk895QVuot4JYwfDPQaGatoXy9mdWZWRtwNbAsTPdVYJOZ7QW+BHyndIFmtgI4j/HQYcL4O81sm5lt6+3tLWM1Zmbs8aDqcxCRCJqtDul7gXVm9gawDtgH5N19C7AJeIniEcDLQD7Mcw9wg7svBX4IfG/CMm8DnnL3PFNw98fcfa27r21vb5+l1RjXnc5SHTMW1SVmfdkiIme6csJhH+N7+wBLQ9kYd9/v7re4+2XAN0LZkfD+YOhDuBYw4H0zawcudfdXwiJ+Bnxywt+9jQo1KQH0pDN0NNZQVaXHg4pI9JQTDq8Cq8zsPDNLUNxobyydwMzazGx0WfcDG0J5LDQvYWargdXAFuAw0GxmF4V5rgXeLVnexcBZFI80KqI7nVFntIhEVny6Cdw9Z2Z3A5uBGLDB3bvM7AFgm7tvBK4CHjIzB7YCd4XZq4EXzQwgDdzh7jkAM/sa8AszK1AMi6+U/NnbgCfd3WdhHU9KdzrDxUsaK/XnRUQqatpwAHD3TRT7DkrLvlUy/BTw1BTzZSiesTTVMp8Gnj7OuG+XU6/TqSedZd1Fs9+XISIyH+gK6SkMZHMMZHM6jVVEIkvhMIWx01gVDiISUQqHKegCOBGJOoXDFFJ6drSIRJzCYQrduq+SiEScwmEKqb4MjTVx6hJlncwlIrLgKBym0J3OqDNaRCJN4TCFVDqrzmgRiTSFwxRS6YzCQUQiTeEwQb7g9PRnWdKszmgRiS6FwwQHB7LkC64+BxGJNIXDBKl0FoAOhYOIRJjCYYLRaxx05CAiUaZwmKBbV0eLiCgcJupJZ6gyaGtQh7SIRJfCYYLuvgztjUliejyoiESYwmECXR0tIqJwmEQXwImIKBwmSaWz6owWkchTOJTIjOTpOzqiIwcRiTyFQ4nRx4MqHEQk6hQOJXQBnIhIkcKhREpPgBMRARQOxxgLB3VIi0jEKRxKdPdlqUvEaEzq8aAiEm0KhxKp/uIFcGa6OlpEok3hUCLVl6FD/Q0iIgqHUrp1hohIkcIhcHd60ll1RouIoHAYc3hohOF8QUcOIiIoHMbo6mgRkXEKh2D8AjiFg4iIwiHQ40FFRMYpHILRI4eORp3KKiKicAhS6QxtDQmqY/pKRES0JQy6+/QEOBGRUWWFg5mtN7P3zGyHmd03xfgVZvasmW03sxfMbGnJuIfN7O3wurWk/Boze93M3jSzX5vZhSXjvmBm75hZl5k9fqorWY7udFansYqIBNOGg5nFgEeA64FO4HYz65ww2XeBn7j7auAB4KEw743A5cAa4ErgXjNrCvM8CnzR3dcAjwPfDPOsAu4HPuXulwBfP/nVK19POkOHwkFEBCjvyOEKYIe773T3YeBJ4KYJ03QCz4Xh50vGdwJb3T3n7oPAdmB9GOfAaFA0A/vD8NeAR9z9MIC798xslWYum8tzcHBYRw4iIkE54XAusKfk895QVuot4JYwfDPQaGatoXy9mdWZWRtwNbAsTPdVYJOZ7QW+BHwnlF8EXGRm/2BmvzGz9UzBzO40s21mtq23t7eM1Ti+nnQWgCXNOlNJRARmr0P6XmCdmb0BrAP2AXl33wJsAl4CngBeBvJhnnuAG9x9KfBD4HuhPA6sAq4Cbgd+YGYtE/+guz/m7mvdfW17e/spVb6nXxfAiYiUKicc9jG+tw+wNJSNcff97n6Lu18GfCOUHQnvD7r7Gne/FjDgfTNrBy5191fCIn4GfDIM7wU2uvuIu/8/4H2KYXHadPcVjxwUDiIiReWEw6vAKjM7z8wSwG3AxtIJzKzNzEaXdT+wIZTHQvMSZrYaWA1sAQ4DzWZ2UZjnWuDdMPx3FI8aCE1RFwE7T2blyjV2dbTCQUQEKDbhnJC758zsbmAzEAM2uHuXmT0AbHP3jRQ35g+ZmQNbgbvC7NXAi+HJamngDnfPAZjZ14BfmFmBYlh8JcyzGbjOzN6h2AT1V+5+cFbW9jhS6QyJeBUtddWn88+IiMwbZT0s2d03Uew7KC37VsnwU8BTU8yXoXjG0lTLfBp4eopyB/59eM2JVFqPBxURKaUrpBm9OlpnKomIjFI4UDxyUGe0iMi4yIeDu+vZ0SIiE0Q+HNKZHJmRgp7jICJSIvLhMPYcBx05iIiMiXw4jD47Ws1KIiLjFA66AE5EZJLIh0PPWLOSTmUVERkV+XDoTmdoqaumpjpW6aqIiJwxFA59egKciMhEkQ+Hnn5dACciMlHkw0G3zhARmSzS4ZDLFzgwoGYlEZGJIh0OvQNZCg6LdXW0iMgxIh0OqdFnR+vIQUTkGJEOh9Gro9UhLSJyrEiHw+h9lRQOIiLHinQ4nN1cw3Wdi2mtT1S6KiIiZ5SyHhO6UF13yRKuu2RJpashInLGifSRg4iITE3hICIikygcRERkEoWDiIhMonAQEZFJFA4iIjKJwkFERCZROIiIyCTm7pWuwykzs15g10nO3gYcmMXqzFf6HsbpuyjS91C0kL+HFe7ePtWIBREOp8LMtrn72krXo9L0PYzTd1Gk76Eoqt+DmpVERGQShYOIiEyicIDHKl2BM4S+h3H6Lor0PRRF8nuIfJ+DiIhMpiMHERGZROEgIiKTRDoczGy9mb1nZjvM7L5K16dSzOxDM/utmb1pZtsqXZ+5YmYbzKzHzN4uKVtkZs+Y2e/D+1mVrONcOc538W0z2xd+F2+a2Q2VrOPpZmbLzOx5M3vHzLrM7N+F8kj+JiIbDmYWAx4Brgc6gdvNrLOytaqoq919TcTO5/4RsH5C2X3As+6+Cng2fI6CHzH5uwD4fvhdrHH3TXNcp7mWA/7S3TuBfwLcFbYJkfxNRDYcgCuAHe6+092HgSeBmypcJ5lD7r4VODSh+Cbgx2H4x8CfzmWdKuU430WkuPtH7v56GO4H3gXOJaK/iSiHw7nAnpLPe0NZFDmwxcxeM7M7K12ZClvs7h+F4W5gcSUrcwa428y2h2anSDSnAJjZSuAy4BUi+puIcjjIuE+7++UUm9juMrN/WukKnQm8eJ53lM/1fhS4AFgDfAT8dUVrM0fMrAH4BfB1d0+XjovSbyLK4bAPWFbyeWkoixx33xfee4CnKTa5RVXKzM4GCO89Fa5Pxbh7yt3z7l4AfkAEfhdmVk0xGH7q7n8biiP5m4hyOLwKrDKz88wsAdwGbKxwneacmdWbWePoMHAd8PaJ51rQNgJfDsNfBv6+gnWpqNENYnAzC/x3YWYG/C/gXXf/XsmoSP4mIn2FdDg1778CMWCDuz9Y2RrNPTM7n+LRAkAceDwq34OZPQFcRfGWzCngPwF/B/wcWE7xNvBfcPcF31F7nO/iKopNSg58CPxFSdv7gmNmnwZeBH4LFELxf6TY7xC930SUw0FERKYW5WYlERE5DoWDiIhMonAQEZFJFA4iIjKJwkFERCZROIiIyCQKBxERmeT/A8olfFjAq92SAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.8013971, G_loss_U: 1.0983299, G_loss_S: 0.006050396, E_loss_t0: 2.123731\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.7689948, G_loss_U: 1.0261761, G_loss_S: 0.006423928, E_loss_t0: 2.1797514\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.7328758, G_loss_U: 0.94700724, G_loss_S: 0.0061936206, E_loss_t0: 2.1108212\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.6990945, G_loss_U: 0.86868376, G_loss_S: 0.006318079, E_loss_t0: 2.2051165\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.6618806, G_loss_U: 0.7970111, G_loss_S: 0.005699341, E_loss_t0: 2.1049972\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.6242012, G_loss_U: 0.73530936, G_loss_S: 0.006388434, E_loss_t0: 2.1761801\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD4CAYAAAAHHSreAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAdWElEQVR4nO3de5Bc5Z3e8e/T3TO6jC4GzRgw0iJsxK4HWxJYwQ7xRlAYIsCAjZMFynZ5y8FsqqDW6yyp4NjlpNhyYdaETf6gKOMNrJ0KxhsIu8LWBm0wlPCNQlwkczGswBd0MUwPAs2MpO7p7l/+6LdnWjMjTY80o5bmPJ+iq0+/5zLvObT66fc957ytiMDMzKxZrt0VMDOzY4/DwczMxnE4mJnZOA4HMzMbx+FgZmbjFNpdgenQ3d0dy5cvb3c1zMyOK08//XQxInommjcrwmH58uVs3ry53dUwMzuuSPrNwea11K0kaZ2klyVtk3TzBPNPk/SopK2SHpe0tGnebZKeT4+rm8ovlPSMpOck/VjSGU3z/kjSi5JekHRf67tqZmbTYdJwkJQH7gQuAXqBayX1jlnsduC7EbESuAW4Na17GXAOsBr4MHCTpEVpnbuAT0fEauA+4KtpnRXAl4F/ERFnAX92+LtnZmaHo5WWw7nAtoh4LSLKwP3AlWOW6QV+lKYfa5rfC2yKiEpEDAFbgXVpXgCNoFgM7EzTXwDujIjdABHx5tR2yczMjlQr4XAq8HrT6+2prNkW4Ko0/UlgoaQlqXydpPmSuoELgGVpueuADZK2A58FvpHKzwTOlPQTST+XtI4JSLpe0mZJm/v6+lrYDTMza9V0Xcp6E7BW0rPAWmAHUI2IjcAG4KfA94CfAdW0zpeASyNiKXAvcEcqLwArgPOBa4FvS3rX2D8YEXdHxJqIWNPTM+HJdjMzO0ythMMORr/tAyxNZSMiYmdEXBURZwNfSWVvp+evR8TqiLgIEPCKpB5gVUQ8mTbxfeC8NL0dWB8RwxHxK+AV6mFhZmZHSSvh8BSwQtLpkjqBa4D1zQtI6pbU2NaXgXtSeT51LyFpJbAS2AjsBhZLOjOtcxHwUpr+O+qtBlJX1JnAa4ezc2Zmdngmvc8hIiqSbgQeAfLAPRHxgqRbgM0RsZ76h/mtkgLYBNyQVu8AnpAEsAf4TERUACR9AXhQUo16WHw+rfMIcLGkF6l3Qf2HiOiflr21tosISpUa+4er7Buusn+4xr5ylf2VKvvLTWXDVfanx75ylQDmd+ZZOLdA15z6Y2F6XpAeXXMKdBZ807/ZdNBs+D2HNWvWhG+Cq9tbrrB99z4G9lcYLFUYKtWfB/en6XLTdKmxTJW95Qo5iXxOFPIin8uRFxRyuaYykW9aJidRqQblao1yJT2qY54nmJ5JnfkcC+YW6JqTp6uzMLIvHbnRehdyOQrpdUc+7V/TfIBqLagF1CKI9Dz6OqjVoNqYbpofEWnd0de1qG9vomWnShKd+Xq9Ows5OvL1x5xCjo68Rso6Czk686Pzc5ra3wlSPWtBpRZU03S1Vi+vpvJa87xUPnq80v42HY/G8WwcowhAMLcjz7yOHPM68sxNj3mdeeYW8szrrJfP6cgzLz3mdOTISYj6+kJI9X5rqT6dSzOby0f+P+dEIZ874P/7yHu96XVO9fWi6X1Qneg9kd4Pjf3OSXR1FpjbkSN9OT4mSXo6ItZMNG9W3CGdVW8O7OfFnXt4cdeekedfFYc41GdOZyE38o278e27e0En8zvnEwSV6ug//GrTo1SpTlheaP5AyudYOLfAnMLoh1PnyHR+ZHpuRy79o88zd+wHQtOHwtzO3EiZgKFSlcFyPdgGUsANlSoMlCaarjJUqlAZqXONSjXYP1yjUquOvG7sz3C1NrJ/gpGgrH/IiFx6Hn1dn24sk5dQ03K5XJrO5Q5YtrEtNT7YpqgWUKnVg3a4WmOoVKFcrde/UTY2pI/0+18hV9+fxheDnKCQz6VjVN/3XG70y8PIvjcdk/pxajo+Gj3GtQje2TfMm3vqLcd9qQVZGp75LxOtkDjsYyjB/I488+cU6OrMM7+zwPzOiV7nmd9RD5O5HXnmFHLp30SOOYV6GM4pjL5uXm5+Z4H8VNO/BQ6H40C1Fvy6f+iAIHhh5x6Kg6WRZZaeMI/eUxZxxar38L6eBSycm7pb5hbo6iyMdMd05I/fbpfF83Msnt/R7mocdxqtlqlqhFw7Vao19je6IcuNrsYa+ytVarUgqH9wB0H6b+R1o3UWkObVWz7VWo3hpi9BlWpt5EvCuNcpnKTRYM81hXzzF4ZGcEr1wNtbrrK3VGGoXG+Z7y1XR1rp7+wbZtfb++rLlOvLlCuHF4R/8YkP8NmPnDZdh3yEw+EY1TdQ4n/+7Nc8sa3IL3cNsG+4fgVwISdWnLSQtWf2cNZ7FtH7nkW8/+RF/tC0g6p/qzx2uzYOpZDPsSCfY8Gc2f9RVanWRs7HtfJcSs8f+r0TZqQ+s/+IH2de6xvk20/8igef2c5wtcaa007gmnOX0XtKPQjOePcC5hTy7a6mmU2zQj5HIZ+j6xgJwmOjFsbTv9nN3ZteZeOLb9CRz/GvP7SU6z56Ou/tWdDuqplZBjkc2qhWC370yzf51qZXeerXu1k8r4Mbzj+Dz523nJ6Fc9pdPTPLMIdDG5QqVf7+2Z18a9OrvNo3xKnvmsfXPt7L1f9s2THTpDSzbPMn0VH0zr5h7nvyt9z7k1/x5kCJ95+yiP9+zWou/eApx/VVRGY2+zgcjpI7H9vGXY+/ymCpwkfP6Ob2f7OKP1zRfUzfIGNm2eVwOApe7Rvkm4+8zPm/38NNF/8+Hzh1cburZGZ2SA6Ho+AHW3YhwW2fWslJi+a2uzpmZpNyR/cMiwjWb9nBuctPdDCY2XHD4TDDfvm7AV7tG+LyVe9pd1XMzFrmcJhhP9i6k3xOXPKBk9tdFTOzljkcZlBE8PCWXZz3viUsWeCb2szs+OFwmEFbt7/Db9/a6y4lMzvuOBxm0MNbdtKRF//qLHcpmdnxxeEwQ2q14Ie/2MXaM3tYPM/DaZvZ8cXhMEOe/u1udr2z311KZnZccjjMkIe37GRuR46Pvf+kdlfFzGzKHA4zoFKtseEXu7jwD07yKKtmdlxyOMyAJ3/1FsXBMh9feUq7q2JmdlgcDjPg4S076erMc8EfvLvdVTEzOywOh2lWrtT4h+d/x8VnnczcDv/Ws5kdnxwO0+wn24q8s2/YXUpmdlxzOEyzh7fsZNHcAn+4oqfdVTEzO2wOh2m0f7jKxhff4JIPnEJnwYfWzI5f/gSbRo+//CaDpYpvfDOz457DYRo9vHUXS7o6+ch7T2x3VczMjojDYZoMlSo8+tIbXPrBUyjkfVjN7PjmT7Fp8v9eeoP9wzV3KZnZrOBwmCYPb9nFyYvmsua0E9pdFTOzI+ZwmAbv7Btm0yt9XLbyFHI5tbs6ZmZHzOEwDTa+8DvKVXcpmdns4XCYBg9v3cWyE+exaunidlfFzGxaOByOUP9giZ9sK3L5yvcguUvJzGYHh8MR+r8v/I5qLfj4Sncpmdns4XA4Qg9v2cn7erp4/ykL210VM7Np01I4SFon6WVJ2yTdPMH80yQ9KmmrpMclLW2ad5uk59Pj6qbyCyU9I+k5ST+WdEYq/2NJfan8OUnXTceOzoQ39uznyV+9xeWr3KVkZrPLpOEgKQ/cCVwC9ALXSuods9jtwHcjYiVwC3BrWvcy4BxgNfBh4CZJi9I6dwGfjojVwH3AV5u29/2IWJ0ef32Y+zbjfrh1FxG4S8nMZp1WWg7nAtsi4rWIKAP3A1eOWaYX+FGafqxpfi+wKSIqETEEbAXWpXkBNIJiMbDz8HahfX6wdSfvP2URZ7x7QburYmY2rVoJh1OB15teb09lzbYAV6XpTwILJS1J5eskzZfUDVwALEvLXQdskLQd+CzwjabtfSp1UT0gaRkTkHS9pM2SNvf19bWwG9Pr9bf28sxv3+byVf5RHzObfabrhPRNwFpJzwJrgR1ANSI2AhuAnwLfA34GVNM6XwIujYilwL3AHan8YWB56qL6R+A7E/3BiLg7ItZExJqenqP/wzo//MUuAC53l5KZzUKthMMORr/tAyxNZSMiYmdEXBURZwNfSWVvp+evp3MHFwECXpHUA6yKiCfTJr4PnJeW74+IUir/a+BDh7VnM+zhLTtZtexdLDtxfrurYmY27VoJh6eAFZJOl9QJXAOsb15AUrekxra+DNyTyvOpewlJK4GVwEZgN7BY0plpnYuAl9Jyzf00VzTKjyWv9Q3yws49XO7fiTazWaow2QIRUZF0I/AIkAfuiYgXJN0CbI6I9cD5wK2SAtgE3JBW7wCeSJd57gE+ExEVAElfAB6UVKMeFp9P6/yppCuACvAW8MfTsaPT6QdbdyH5KiUzm70UEe2uwxFbs2ZNbN68+aj8rYjgor/axIldnfztn/zzo/I3zcxmgqSnI2LNRPN8h/QUvdo3xLY3B92lZGazmsNhin771hAAHzjVI7Ca2ezlcJii4kAZgO4Fc9pcEzOzmeNwmKLiUP0qW4eDmc1mDocpKg6U6erMM68z3+6qmJnNGIfDFBUHS3QvdKvBzGY3h8MU9Q+V3KVkZrOew2GKigNllnR1trsaZmYzyuEwRe5WMrMscDhMQaVa4629ZXcrmdms53CYgt17h4mA7gXuVjKz2c3hMAXFQd/jYGbZ4HCYAoeDmWWFw2EK+gcbQ2e4W8nMZjeHwxQ0Wg5L3HIws1nO4TAFfYMlOvM5Fs2d9DeSzMyOaw6HKSgOlOle0En6ZTszs1nL4TAF/UMldymZWSY4HKagOFjyyWgzywSHwxTUu5XccjCz2c/h0KKIqI/I6nGVzCwDHA4t2rOvwnA1PCKrmWWCw6FFfekehx63HMwsAxwOLfLQGWaWJQ6HFo0OneFwMLPZz+HQotGhM3zOwcxmP4dDi4qDJXKCE+Y7HMxs9nM4tKg4WObErjnkcx46w8xmP4dDi3x3tJllicOhRfVw8MloM8sGh0OL3HIwsyxxOLSof9DjKplZdjgcWrC3XGFvuerhus0sMxwOLSgO+LejzSxbHA4tKA6loTM8rpKZZYTDoQXFgRQOXQ4HM8sGh0MLio1xlRa6W8nMsqGlcJC0TtLLkrZJunmC+adJelTSVkmPS1raNO82Sc+nx9VN5RdKekbSc5J+LOmMMdv8lKSQtOZIdnA6jIyr5JaDmWXEpOEgKQ/cCVwC9ALXSuods9jtwHcjYiVwC3BrWvcy4BxgNfBh4CZJi9I6dwGfjojVwH3AV5v+5kLgi8CTh7tj06l/sMTieR10FtzQMrNsaOXT7lxgW0S8FhFl4H7gyjHL9AI/StOPNc3vBTZFRCUihoCtwLo0L4BGUCwGdjZt7y+A24D9U9iXGVMcLHs0VjPLlFbC4VTg9abX21NZsy3AVWn6k8BCSUtS+TpJ8yV1AxcAy9Jy1wEbJG0HPgt8A0DSOcCyiPjhoSol6XpJmyVt7uvra2E3Dl+fh84ws4yZrn6Sm4C1kp4F1gI7gGpEbAQ2AD8Fvgf8DKimdb4EXBoRS4F7gTsk5YA7gD+f7A9GxN0RsSYi1vT09EzTbkysf7BEj8PBzDKklXDYwei3fYClqWxEROyMiKsi4mzgK6ns7fT89YhYHREXAQJekdQDrIqIxjmF7wPnAQuBDwCPS/o18BFgfbtPSrtbycyyppVweApYIel0SZ3ANcD65gUkdadv/QBfBu5J5fnUvYSklcBKYCOwG1gs6cy0zkXASxHxTkR0R8TyiFgO/By4IiI2H9FeHoFypcY7+4bdrWRmmVKYbIGIqEi6EXgEyAP3RMQLkm4BNkfEeuB84FZJAWwCbkirdwBPSALYA3wmIioAkr4APCipRj0sPj+tezZN+ht3RzsczCxDJg0HgIjYQP3cQXPZ15qmHwAemGC9/dSvWJpomw8BD03yd89vpX4zqX/Q4yqZWfb4wv1J9DVugHPLwcwyxOEwica4Sr5aycyyxOEwif4hj6tkZtnjcJhEcaDEvI488ztbOj1jZjYrOBwmURwsudVgZpnjcJhE0b8dbWYZ5HCYRNHjKplZBjkcJlFvObhbycyyxeFwCNVa8NaQWw5mlj0Oh0PYvbdMLTx0hpllj8PhEBpDZ3hEVjPLGofDITR+O9otBzPLGofDITgczCyrHA6HUEzdSh5XycyyxuFwCMXBEh15sWieh84ws2xxOBxCcaDEkq45pB8rMjPLDIfDIXhcJTPLKofDIfQPlVnS5fMNZpY9DodDKA747mgzyyaHw0FERH1cJXcrmVkGORwOYqBUoVyt+TJWM8skh8NBNH472kNnmFkWORwOonEDnM85mFkWORwOwkNnmFmWORwOot/hYGYZ5nA4iL7BMhKcML+j3VUxMzvqHA4HURwsceL8Tgp5HyIzyx5/8h1E/6BvgDOz7HI4HERxsOzLWM0ssxwOB1F0y8HMMszhcBAeV8nMsszhMIF95SpD5arHVTKzzHI4TGDkBjgP121mGeVwmMBIOLjlYGYZ5XCYQL/HVTKzjHM4TKDRcljicDCzjHI4TGAkHLrcrWRm2dRSOEhaJ+llSdsk3TzB/NMkPSppq6THJS1tmnebpOfT4+qm8gslPSPpOUk/lnRGKv93kn7RVN47HTs6FcXBMgvnFpjbkT/af9rM7JgwaThIygN3ApcAvcC1E3xg3w58NyJWArcAt6Z1LwPOAVYDHwZukrQorXMX8OmIWA3cB3w1ld8XER9M5X8J3HG4O3e4ioMl/wKcmWVaKy2Hc4FtEfFaRJSB+4ErxyzTC/woTT/WNL8X2BQRlYgYArYC69K8ABpBsRjYCRARe5q225WWO6qKgyUPnWFmmdZKOJwKvN70ensqa7YFuCpNfxJYKGlJKl8nab6kbuACYFla7jpgg6TtwGeBbzQ2JukGSa9Sbzn86USVknS9pM2SNvf19bWwG60rDpZ9pZKZZdp0nZC+CVgr6VlgLbADqEbERmAD8FPge8DPgGpa50vApRGxFLiXpu6jiLgzIt4H/EdGu5sOEBF3R8SaiFjT09MzTbtR5xFZzSzrWgmHHYx+2wdYmspGRMTOiLgqIs4GvpLK3k7PX4+I1RFxESDgFUk9wKqIeDJt4vvAeRP87fuBT7S+O0duuFpj995hdyuZWaa1Eg5PASsknS6pE7gGWN+8gKRuSY1tfRm4J5XnU/cSklYCK4GNwG5gsaQz0zoXAS+l5VY0bfoy4J8OZ8cO11tDvgHOzKww2QIRUZF0I/AIkAfuiYgXJN0CbI6I9cD5wK2SAtgE3JBW7wCekASwB/hMRFQAJH0BeFBSjXpYfD6tc6OkjwHDqfxz07KnLeob8G9Hm5lNGg4AEbGB+rmD5rKvNU0/ADwwwXr7qV+xNNE2HwIemqD8i63Uaab0p5ZDj8dVMrMM8x3SYxQHGndHu+VgZtnlcBhjdERWh4OZZZfDYYz+oTJzO3J0dXroDDPLLofDGMWBEku65pBOopuZZZLDYYy+wZK7lMws8xwOYxQHy/T4BjgzyziHwxgeOsPMzOFwgFot6B8qe+gMM8s8h0OTt/cNU62FWw5mlnkOhyb9gx46w8wMHA4H6Gv8drS7lcws4xwOTYqDaVwltxzMLOMcDk2KHpHVzAxwOBygf6hEIScWz+tod1XMzNrK4dCkOFDmxK5OcjkPnWFm2eZwaFL0DXBmZoDD4QBFj6tkZgY4HA5QHCzT3eXLWM3MHA5JRLjlYGaWOBySwVKFUqVGt2+AMzNzODT0pxvgfELazMzhMKI4MnSGw8HMzOGQFEcG3XO3kpmZwyHp87hKZmYjHA5JY7juE30pq5mZw6GhOFjihPkdFPI+JGZm/iRMigNlX6lkZpY4HJL+IY+rZGbW4HBIioNl/wKcmVnicEiKA245mJk1OByA/cNVBkoVejyukpkZ4HAAoH+oMXSGu5XMzMDhAIz+dvSSLrcczMzA4QA0DZ3hbiUzM8DhADSPyOpuJTMzcDgA0Dcy6J5bDmZm4HAA6t1KC+YUmNuRb3dVzMyOCQ4H0m9Hu0vJzGxES+EgaZ2klyVtk3TzBPNPk/SopK2SHpe0tGnebZKeT4+rm8ovlPSMpOck/VjSGan830t6MW3rUUmnTceOHkr/oG+AMzNrNmk4SMoDdwKXAL3AtZJ6xyx2O/DdiFgJ3ALcmta9DDgHWA18GLhJ0qK0zl3ApyNiNXAf8NVU/iywJm3rAeAvD3fnWlUcLHnoDDOzJq20HM4FtkXEaxFRBu4HrhyzTC/wozT9WNP8XmBTRFQiYgjYCqxL8wJoBMViYCdARDwWEXtT+c+BkVbITKl3K7nlYGbW0Eo4nAq83vR6eyprtgW4Kk1/ElgoaUkqXydpvqRu4AJgWVruOmCDpO3AZ4FvTPC3/y3wDxNVStL1kjZL2tzX19fCbkysUq2xe6/Dwcys2XSdkL4JWCvpWWAtsAOoRsRGYAPwU+B7wM+AalrnS8ClEbEUuBe4o3mDkj4DrAG+OdEfjIi7I2JNRKzp6ek57Iq/tbdMhO9xMDNr1ko47GD02z7Uu3l2NC8QETsj4qqIOBv4Sip7Oz1/PSJWR8RFgIBXJPUAqyLiybSJ7wPnNbYn6WNpO1dEROmw9qxFxYHGDXBuOZiZNbQSDk8BKySdLqkTuAZY37yApG5JjW19GbgnledT9xKSVgIrgY3AbmCxpDPTOhcBL6Xlzga+RT0Y3jySnWuFh84wMxuvMNkCEVGRdCPwCJAH7omIFyTdAmyOiPXA+cCtkgLYBNyQVu8AnpAEsAf4TERUACR9AXhQUo16WHw+rfNNYAHwv9N6v42IK6ZjZyfSP+S7o83Mxpo0HAAiYgP1cwfNZV9rmn6A+mWnY9fbT/2KpYm2+RDw0ATlH2ulTtOl0a3kS1nNzEZl/g7p4mCJzkKOhXNaykkzs0xwOAyW6Vkwh9SFZWZmOBx8d7SZ2QQcDh5XycxsHIfDYMk3wJmZjZHpcIgI+j2ukpnZOJkOh3f2DVOpBUscDmZmB8h0OIzcHe1uJTOzA2Q8HOo3wPW45WBmdoCMh0O95eBuJTOzA2U7HAbcrWRmNpFMh8N73jWPi3tP4oT5Dgczs2aZHlDo4rNO5uKzTm53NczMjjmZbjmYmdnEHA5mZjaOw8HMzMZxOJiZ2TgOBzMzG8fhYGZm4zgczMxsHIeDmZmNo4hodx2OmKQ+4DeHuXo3UJzG6hyvfBxG+VjU+TjUzebjcFpE9Ew0Y1aEw5GQtDki1rS7Hu3m4zDKx6LOx6Euq8fB3UpmZjaOw8HMzMZxOMDd7a7AMcLHYZSPRZ2PQ10mj0PmzzmYmdl4bjmYmdk4DgczMxsn0+EgaZ2klyVtk3Rzu+vTLpJ+LekXkp6TtLnd9TlaJN0j6U1JzzeVnSjpHyX9U3o+oZ11PFoOciz+i6Qd6X3xnKRL21nHmSZpmaTHJL0o6QVJX0zlmXxPZDYcJOWBO4FLgF7gWkm97a1VW10QEaszdj333wDrxpTdDDwaESuAR9PrLPgbxh8LgL9K74vVEbHhKNfpaKsAfx4RvcBHgBvSZ0Im3xOZDQfgXGBbRLwWEWXgfuDKNtfJjqKI2AS8Nab4SuA7afo7wCeOZp3a5SDHIlMiYldEPJOmB4CXgFPJ6Hsiy+FwKvB60+vtqSyLAtgo6WlJ17e7Mm12UkTsStO/A05qZ2WOATdK2pq6nTLRnQIgaTlwNvAkGX1PZDkcbNRHI+Ic6l1sN0j6l+2u0LEg6td5Z/la77uA9wGrgV3Af21rbY4SSQuAB4E/i4g9zfOy9J7IcjjsAJY1vV6ayjInInak5zeBh6h3uWXVG5JOAUjPb7a5Pm0TEW9ERDUiasC3ycD7QlIH9WD4XxHxf1JxJt8TWQ6Hp4AVkk6X1AlcA6xvc52OOkldkhY2poGLgecPvdasth74XJr+HPD3baxLWzU+EJNPMsvfF5IE/A/gpYi4o2lWJt8Tmb5DOl2a99+APHBPRHy9vTU6+iS9l3prAaAA3JeV4yDpe8D51IdkfgP4z8DfAX8L/B71YeD/KCJm/YnagxyL86l3KQXwa+BPmvreZx1JHwWeAH4B1FLxf6J+3iF774ksh4OZmU0sy91KZmZ2EA4HMzMbx+FgZmbjOBzMzGwch4OZmY3jcDAzs3EcDmZmNs7/B6ha66D0L5g3AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.5865419, G_loss_U: 0.6862581, G_loss_S: 0.005801568, E_loss_t0: 2.2071416\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.5491813, G_loss_U: 0.65497947, G_loss_S: 0.0058335937, E_loss_t0: 2.1596715\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.5181143, G_loss_U: 0.6510353, G_loss_S: 0.00587142, E_loss_t0: 2.2020822\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.4821975, G_loss_U: 0.69487125, G_loss_S: 0.0063957865, E_loss_t0: 2.1971588\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.4429839, G_loss_U: 0.83312386, G_loss_S: 0.0057524526, E_loss_t0: 2.2608519\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.3822042, G_loss_U: 1.1688379, G_loss_S: 0.0065415185, E_loss_t0: 2.202294\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.3626974, G_loss_U: 0.73953766, G_loss_S: 0.00663908, E_loss_t0: 2.2230406\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.2951199, G_loss_U: 0.8380812, G_loss_S: 0.0064137955, E_loss_t0: 2.2317638\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAD4CAYAAAAQP7oXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAuGElEQVR4nO3deXzV5Zn38c+VhYRACJAEsrBvIksAG3BDNquCgAK1FTs6tfPMOG112j7PtDPaPtPFPo7a2k7tdJmhlqrtqG1d2ETFoggKVoJCWISILEI2NrMACZDkev44v9BjBDlAkhNyvu/XK6+cc/+Wc/0OJ+fivn/3Yu6OiIhIJOKiHYCIiFw4lDRERCRiShoiIhIxJQ0REYmYkoaIiEQsIdoBtLSMjAzv169ftMMQEblgrFu37oC7Z55qW7tPGv369aOgoCDaYYiIXDDMbPfptql5SkREIqakISIiEVPSEBGRiClpiIhIxJQ0REQkYkoaIiISMSUNERGJWLsfp9Ee7f3wKAvXl1Df4CTEG4lxcSTGGwnxod+J8XGhx3GNj40O8XEkJsQxuEdnuqZ0iPYliMgFSknjAlJSUcMvXt3OHwv2cKL+3NZBMYPhOV24YmAGlw9MZ1y/7nRK0sdARCKjb4sLQHlVLb98dTtPvrUHx7l5bG/unDyIHqnJnKhvCH6cuvoGTjQ4J+oaqGto4HidU9cQ2naivoGaE/UU7qlk9fsHePSNXcxbuYOEOGN0765cMTCdywdmMKZPV5IT46N9ySLSRll7X7kvPz/fL9RpRPZXH+O/Xnuf37+5m/oG57P5vbhz8iB6dUs573PXHK9n3e4PWf3+AVa/f5DCvRU0OCQlxJHfr9vJmkhebhoJ8br1JRJLzGydu+efaltENQ0zmwo8DMQDj7j7A0229wXmA5nAIeBWd98bbHsQmB7s+gN3/0NQvgpIDcp7AG+5+ywz+ybwN2HxXQxkuvuhM8XRXhw8fIx5K3fw2JpdHK9rYM4lvfjqlMH0ST//ZNGoY4d4xg/OYPzgDACqak+wduchVr9/kNXvH+RHL20DoHNSAlcOSmd6Xg5XD+2hpiyRGHfGmoaZxQNFwDXAXmAtcIu7bwnb50/AEnd/zMymAF9099vMbDrwdWAakASsAK5296omr/EMsNDdH29SPhP43+4+JZI4TuVCqml8eOQ4v161g0dX76LmRD2zRufy1asH0z+jU6vHcvDwMf6y8xCvbz/An7eUs6/6GEkJcUy+qAfX52UrgYi0Y+db0xgHbHf3HcHJngJuBMK/rIcB/yd4/CqwIKx8pbvXAXVmVghMBf4YFlwXYArwxVO89i3Ak2cRxwWpsuYEv1m1g/lv7OLI8Tpm5OXwtasHMahH6pkPbiHpnZO4fmQ214/M5v/dOIKC3R+ydGMpSzeW8uLmMiUQkRgVyV96LrAn7Ple4NIm+2wA5hBqOpoNpJpZelD+XTP7MZACTObjX/KzgOWnqH2kEEowd51FHI3H3gHcAdCnT58zXmA0rd11iL97dC3VtXVMG5HF1z89hIuyopcsTiUuzhjXvzvj+nfnOzOGKYGIxLDm+uv+BvBzM7sdWAkUA/XuvszMxgKrgf3AGqC+ybG3AI+c4pwzgTfc/dDZBuPu84B5EGqeOtvjW9OzbxeDw/NfHc/wnLRoh3NGp0ogzxeW8MKmso8lkE9f3IOUDkogIu1JJH/RxUDvsOe9grKT3L2EUE0DM+sMfMbdK4Jt9wH3BdueIHRfguB5BqFmp9mneN25/LVpKqI4LkRF5dVcnNPlgkgYTX0kgcwcTsGuQyzdWHoygXRMjGfKxT2YmZfDpIsy1ZVXpB2IJGmsBQabWX9CX9Jzgc+H7xB8+R9y9wbgHkI9qRpvond194NmlgfkAcvCDr2J0A302ibnSwMmAreeTRwXGnenqKyaWWNyox3KeYuPMy4dkM6lA9L5zszhrN11iCWFJSzdWMbzhaV0TkrgmmE9mTkqm/GDMumQoG68IheiMyYNd68zs7uAlwh1dZ3v7pvN7F6gwN0XAZOA+83MCTVP3RkcngisMjOAKkJdcevCTj8XOFW32dnAMnc/cqY4zupq25iSylqqj9W1uXsY5ys+zrhsQDqXDUjnezOHs2bHQZZsKOWFTaU8904xaR0TmTo8ixmjsrl8QLrGgYhcQDS4L4pe3bqPLz66lj996XLG9use7XBa3PG6Bl7fvp/FG0p5eUs5h4/Vkd6pA9NGZjEjL4dx/boTF2fRDlMk5p334D5pGVvLqgEYEsWuta2pQ0IcU4b2ZMrQntSeqGfFtv0sLizh6XV7+f2bH5CdlswdEwZwy7g+uv8h0kYpaURRUXk12WnJpKUkRjuUVpecGM/UEVlMHZHFkWN1LN+6j/95czffX7yFeSt38E9TBvPZ/F4kqulKpE3RX2QUbSurZkjP2KhlfJJOSQncMCqHp+64jP/5+0vJTkvmW89tZMqPV/D0ur3U1TdEO0QRCShpREldfQPb9x9udzfBz4eZceWgDJ758hX89vaxpHVM5Bt/2sC1/7GSheuLaWho3/ffRC4EShpRsuvgUY7XNXCRahofY2ZMHtqDxXeN579v+xSJ8XF87an1THt4FS9uKqO9d94QacuUNKKkqDx0E1w1jdMzM64bnsULX7uKn90yhhMNDXzp9+uY+fPXeWVruZKHSBQoaUTJ1rJq4gwG9egc7VDavLg444ZROSz7+gR+/NlRVNac4O8eLWDOr1bz+nsHlDxEWpF6T0VJUVk1/dI7qWvpWUiIj+Mzn+rFDaNzeHrdXv5z+Xvc+pu/MKhHZ24clcONo3Obdc0REfk4JY0oKSpXz6lzlRgfxy3j+jDnklyee7uYZ98u5scvF/Hjl4u4pE9XZo3JZfrIbNI7J0U7VJF2R0kjCmpP1LPr4BFmjMqJdigXtKSEeOaO68PccX3Y++FRFm8oZeH6Yr6zcDPfX7yFqwZnMGt0LtcM66np2kWaif6SomD7vsM0OAzVTfBm06tbCl+eNJAvTxrI1rIqFrxTwqL1xXz9D+vpmBjPtcN7Mmt0LuMHZ2jAoMh5UNKIgm2N04eoeapFDM3qwt3TuvAv111Ewe4PWbC+mKUbS1m4voTunTowfWQ2N4/tzYjcC286epFoU9KIgm3l1XRIiKOfbtq2qPD1Pr43czivFe1n4fpi/liwh9+9uZsrB6XzpYkDGT8og2AmZhE5AyWNKNhWVs2gzM6aErwVdUiI45phPblmWE8qa07w5FsfMP/1ndz2m7cYlt2Ff5w4gOkjs/VvInIG+guJgqLyag3qi6K0jol8aeJAVv3rZH74mTyO1dXztafWM+mhFTz6xk6OHq8780lEYpSSRiurPHqC0spa3c9oA5IS4vnc2N68/L8n8uu/zadnl2S+t3gLVzzwCj95uYiDh49FO0SRNkfNU62saF/oJrh6TrUdcXF2sumqYNch/uu1Hfxs+XvMW/k+n8vvzd+PH6BBgyIBJY1WdrLnlJJGm5TfrzuP9OvO9n3VzFu5gyff+oDfv7mb60dm83fj+zOmd1fdNJeYpqTRyraVVZOalEBOWnK0Q5FPMKhHKj+8aRT/fO1FzH9jJ0+8+QFLCkvp0z2FGXnZzMjL4eLsVCUQiTlKGq1sW3k1Q7L0ZXOh6NklmXumXcxdkwfxwqYylhSW8t8rd/DLFe8zILMTM/NymDkqm0ExsmSvSERJw8ymAg8D8cAj7v5Ak+19gflAJnAIuNXd9wbbHgSmB7v+wN3/EJSvAhr/0noAb7n7rGDbJOCnQCJwwN0nBuW7gGqgHqg73cLnbZW7U1RezbQR2dEORc5SanIin8vvzefye3Pw8DFe3FzG4g0l/OyV93h4+XsMzUpl5qgcZuRl0ze9U7TDFWkxZ0waZhYP/AK4BtgLrDWzRe6+JWy3h4DH3f0xM5sC3A/cZmbTgUuA0UASsMLMXnD3Kne/Kuw1ngEWBo+7Ar8Eprr7B2bWo0lIk939wLldbnTtqz5GxdETXNRT06FfyNI7J/E3l/blby7ty76qWpZuLGVxYSk/emkbP3ppG3m90piRl830vBxyu3aMdrgizSqSLrfjgO3uvsPdjwNPATc22WcY8Erw+NWw7cOAle5e5+5HgEJgaviBZtYFmAIsCIo+Dzzr7h8AuPu+s7qiNqzxJvhFWV2iHIk0lx5dkrn9yv488+UreOPuKXzr+qEA/PvSrVz5wCt89r9Ws3B9MSe0zrm0E5EkjVxgT9jzvUFZuA3AnODxbCDVzNKD8qlmlmJmGcBkoHeTY2cBy929Kng+BOhmZivMbJ2Z/W3Yvg4sC8rvOF3AZnaHmRWYWcH+/fsjuMTWodX62rfcrh25Y8JAFt01nte+OYlvXncRBw4f52tPreeqB1/lF69u59CR49EOU+S8NNeN8G8APzez24GVQDFQ7+7LzGwssBrYD6whdD8i3C3AI01i+hRwNdARWGNmb7p7ETDe3YuDJquXzWyru69sGoy7zwPmAeTn57eZZd22llWTmZpE904doh2KtLC+6Z24c/IgvjxxICuK9vHbN3bxo5e28bPl7zF7TC5fvLK//vMgF6RIkkYxH60d9ArKTnL3EoKahpl1Bj7j7hXBtvuA+4JtTwBFjccFtY9xhGonjfYCB4PmrCNmthIYBRS5e3Fwzn1m9lxw7MeSRltVVF7NRRoJHlPi4owpQ3syZWhPisqr+e0bu3junb08tXYPVw5K54tX9GfK0B7Exak3nVwYImmeWgsMNrP+ZtYBmAssCt/BzDLMrPFc9xDqSYWZxQfNVJhZHpAHLAs79CZgibvXhpUtBMabWYKZpQCXAu+aWSczSw3O1Qm4Fth0dpcbPQ0NrtX6YtyQnqncP2cka+6+mn+ZehE79h/h7x8vYMqPV/DbN3Zy+JjmvJK274w1DXevM7O7gJcIdbmd7+6bzexeoMDdFwGTgPvNzAn9z//O4PBEYFUwJqGKUFfc8L+MucBHuu+6+7tm9iKhm+YNhLr4bjKzAcBzwbkSgCfc/cVzvO5W98Gho9SeaND0IUK3Th34yqRB/MNVA3hpcxnzX9/J9xdv4SfLivhsfm9uv6Kfpi2RNsvc20yTf4vIz8/3goKCaIfBS5vL+MffrWPBnVcyunfXaIcjbcz6PRX89o2dPF9YSr07lw9I58bROUwdkU1ax8RohycxxszWnW4cnGa5bSVFQXfbwT00RkM+bnTvrjw8dwxv3D2Fr109mJKKGv71mY2Mve/PfOl363hxUym1J5r2IRFpfZpGpJVsLa+mT/cUOiXpLZfT69klma9/eghfu3owhXsrWbC+mMUbSnlxcxmpyQlMG5HFrNG5XDognXjdPJco0DdYKykq001wiZyZMap3V0b17sq3r7+Y1e8fZMH6Yp4vLOWPBXvp2SWJmXk5zBqTy/CcLprLTFqNkkYrOFZXz84DR7h2eM9ohyIXoIT4OCYMyWTCkExqZ9fz53fLWfBOCY+t2cUjr+9kYGYnbhydy2c+1UvTlkiLU9JoBTv2H6GuwTV9iJy35MR4ZuTlMCMvh4qjx3l+YykL15fwk5eL+Omfi5gytCe3Xd6XqwZlaOyHtAgljVZwcvoQNU9JM+qa0uHkxIl7Dh3lqbUf8NRbe/jzu+X0TU/h1kv78tn8XnRN0QwE0nzUe6oVbCurJiHO6J+hKbOlZfTunsI3rxvK6num8PDc0fRITeK+pe9y6b8v5xt/2sCGPRXRDlHaCdU0WsG2smoGZnamQ4JytLSspIR4bhydy42jc9lSUsXv/7KbBe8U8/S6veT1SuO2y/oyc1QOyYnx0Q5VLlD6FmsFjav1ibSmYTld+PfZI3nzW1fz/RuGc/R4Pd98upBL/3059z2/hV0HjkQ7RLkAqabRwg4fq2PvhzXMHdt0RniR1tElOZEvXNGPv728L2/uOMTv39zNb9/Yxa9X7WT8oAxmj8ll6ogsjSGSiOhT0sL+uoaGek5JdJkZlw9M5/KB6ZRX1fLkWx/wzNt7+ec/beD/LtjEtcN7MntMLuMHZZAQr0YIOTUljRbWOH2Iek5JWxI+8rxg94c8+3YxzxeWsHB9CRmdk7hxdA6zNXBQTkFJo4VtK68mpUM8vbpp0JW0PWbG2H7dGduvO9+7YRivbt3Hs28X8/iaXfzm9Z0M7tGZ2ZfkMmt0LjkaOCgoabS4bWXVDO6ZqoFW0uYlJcQzdUQ2U0dkU3H0OEsKS3nunWJ++OI2fvTSNi7t3505Y3oxbWQWqcmaeTdWKWm0sKLyaqYM7RHtMETOSteUDtx6WV9uvawvuw8eYcE7JTz3zl7+5ZlC/m3hJj49rCezR+cy8aJMEnX/I6YoabSgA4ePceDwcU1UKBe0vumd+NqnB/PVqwexfk8Fz71TzOINJTxfWEq3lERmjgpNnDimd1fd/4gBShotqPEm+FD1nJJ2wMwY06cbY/p0499mDGNl0X6ee6eYP6zdw+NrdtM3PYVZo3OZNSZXsx+0Y0oaLWhb0N12SJYWXpL2JTE+jqsv7snVF/ekuvYEL24qY8H6Yn72yns8vPw9RvfuyuwxuczIyya9c1K0w5VmpKTRgorKq+mWkkim/mikHUtNTuSz+b35bH5vyiprWbShmOfeKeG7izbzgyVbmDAkk9ljcrlmWE9NX9IOKGm0oK1l1VyUlap2XokZWWnJ3DFhIHdMGMjWsiqee6eYhe+U8MrWfaQmJXD9yGzmXJLL2H7d1aPwAhVRtwczm2pm28xsu5ndfYrtfc1suZkVmtkKM+sVtu1BM9sU/NwcVr7KzNYHPyVmtiBs26SgfLOZvRZpHG2Ju1NUVq1BfRKzhmZ14Z5pF/PG3VN44u8v5boRWSwpLOHmeW8y8aFX+cnLRZr/6gJ0xpqGmcUDvwCuAfYCa81skbtvCdvtIeBxd3/MzKYA9wO3mdl04BJgNJAErDCzF9y9yt2vCnuNZ4CFweOuwC+Bqe7+gZn1OIs42oziihqOHK/XRIUS8+LjjCsGZXDFoAzuvXE4L20u49m3i/nPV97jZ8vf41N9uzHnklxmjMwhLUXjP9q6SGoa44Dt7r7D3Y8DTwE3NtlnGPBK8PjVsO3DgJXuXufuR4BCYGr4gWbWBZgCLAiKPg886+4fALj7vrOIo83YdrLnlJKGSKOUDgnMHtOL3/2vS1lz99XcPW0oVTUn+PZzmxh735/5yv+s489byjlR3xDtUOU0IrmnkQvsCXu+F7i0yT4bgDnAw8BsINXM0oPy75rZj4EUYDLQtGYwC1ju7lXB8yFAopmtAFKBh9398QjjAMDM7gDuAOjTp08El9j8GntODVbzlMgpZaUl86WJA/nHCQPYXFLFM2/vZdH6EpZuLKN7pw7cEIz/GNUrTfcF25DmuhH+DeDnZnY7sBIoBurdfZmZjQVWA/uBNUB9k2NvAR5pEtOngKuBjsAaM3vzbIJx93nAPID8/Hw/66tpBkVl1eSkJdNF0y2IfCIzY0RuGiNy0/jW9Rezsmg/z75dzBN/+YBHV++id/eOTB+Zw8xR2QzL1gSK0RZJ0igGwheD6BWUneTuJYRqGphZZ+Az7l4RbLsPuC/Y9gRQ1HicmWUQanaaHXa6vcDBoDnriJmtBEYF5Z8YR1vS2HNKRCIXPv6jsuYEyzaXsaSwlF+v2sF/vfY+AzI6MWNUDjPzslWLj5JIksZaYLCZ9Sf0JT2X0H2Hk4Iv/0Pu3gDcA8wPyuOBru5+0MzygDxgWdihNwFL3L02rGwhoVpLAtCBUBPUfwBbzxRHW3GivoEd+48w8aLMaIcicsFK6/jX8R+HjhznxU1lLN5QcvIG+tCsVGbkZTMjL4d+GoHeas6YNNy9zszuAl4C4oH57r7ZzO4FCtx9ETAJuN/MnFDz1J3B4YnAqqA6WQXc6u51YaefCzzQ5PXeNbMXCd00bwAecfdNAKeK49wuu2XtPniE4/UN6m4r0ky6d+rA5y/tw+cv7cO+6lpe2BhKIA8tK+KhZUWMzE1j5qhspuflkKsp3FuUuUelyb/V5Ofne0FBQau+5pLCEu564h2e/+p4huektepri8SSkooani8sZUlhCRv2VgKQ1yuNCYMzmTAkkzF9umoW3nNgZuvcPf9U2zQivAUUlVUTZzAwU3NOibSknK4d+YcJA/iHCQPYffAISwpLeWXrPn712vv8/NXtdE5K4PKB6UwYksnEwZn0SU+JdsgXPCWNFrCtvJp+GZ00z45IK+qb3ok7Jw/izsmDqKw5wZr3D/Ba0QFWFu3n5S3lwT4pJ2shlw9Mp3OSvgLPlt6xFrCtrJphOZoOXSRa0jomnlyF0N3ZeeAIK4v2s/K9Azy9bi+/e3M3CXHGJX27MXFIJhOHZGo99AgpaTSzmuP17D50lFljcqMdiogQGgcyILMzAzI7c/uV/TlWV8+63R+ysugAq97bz49eCi1n26d7CtNGZnH9iGzyNKDwtJQ0mtn2fYdxRz2nRNqopIR4rhiYwRUDM7h72lD2Vx/jla3lLN1Yxm9W7eS/X9tBr24duX5kNtePzNaI9CaUNJrZ1rLQbCga2CdyYchMTeLmsX24eWwfKo4eZ9mWcpZuLOW3b+xk3sod5HbtyLQRWVyfl60lbVHSaHZF5dV0SIijb7oGG4lcaLqmdOBz+b35XH5vKo+e4OV3QwnksTW7eOT1neSkJTNtZDbXj8xiTO9uMbkmiJJGM9tWfpjBPToTH4MfJpH2JC0lkZs+1YubPtWLypoTLA8SyO/W7OY3r+8kOy2Z6SOzuWF0DiNzY6cJS0mjmW0rq+LKQRnRDkNEmlFax0TmXNKLOZf0oqr2BK+8u48lhSUnayD90lO4YVQOM0fltPs5sZQ0mlHF0eOUVx3TTXCRdqxLciKzxuQya0wulUdP8OLmUhZtKOHnr27nZ69sZ2hWKjeMzmFmXg69u7e/wYRKGs2oqPwwgFbrE4kRaSmJJ2+i76uuZWlhKIH88MVt/PDFbYzp05UbRuUwPS+bHqnJ0Q63WShpNKNtQc8prdYnEnt6pCZz+5X9uf3K/uw5dJTFhSUs3lDK9xdv4QdLtnDZgHRuGJXDdcOz6NapQ7TDPWdKGs1oW3k1qckJZHVpH/+jEJFz07t7Cl+ZNIivTBrEe+XVLN5QwqINJdz97Eb+74JNXD4wnetHZnPtsJ6kd06KdrhnRbPcNqNb5r3Jsbp6nv3Kla3yeiJy4XB3NhVXsXRTKUs3lrL74FHiDC4bkM60kdlcN7xnm2nC0iy3raSksoZRvbpGOwwRaYPMjJG90hjZK41/ue4i3i2t5oVNpTy/sZR/W7CJ7yzcxNh+3bl+RBZTR2STldY2EkhTShrNpKHBKa2oZeqItvkPLSJth5kxLKcLw3K68H+uGcJ7+w6zdGMpL2ws43uLt/C9xVvI79uNaSOzmTYii5w2tLCUkkYzOXjkOMfrG7RqmIicFTNjSM9UhvRM5eufHsL2fYd5cVMpSzeW8YMloZvoI3K7MGFwaDbeS/p2i+rCUkoazaSkogaA7DQlDRE5d4N6dOauKYO5a8pgdh04wgubynh12z7mrdzBL1e8f3JhqcYp3Vt7LIiSRjNpTBo5XdU8JSLNo19GJ748aSBfnjSQ6toTrH7/IK8V7f/IwlIDMjoxYUgmE4ZkcNmAdFI6tOzXupJGMymprAUgRzUNEWkBqcmJXDc8i+uGZ+Hu7AgWlnqtaD9Prf2AR1fvokN8HGP7dws1ZV2UyUU9U5t9TqyIkoaZTQUeBuKBR9z9gSbb+wLzgUzgEHCru+8Ntj0ITA92/YG7/yEoXwU0joLrAbzl7rPMbBKwENgZbHvW3e8NjtkFVAP1QN3puoRFQ0lFDR0T4+makhjtUESknTMzBmZ2ZmBmZ754ZX9qT9RTsOtDXivax8qiA9z/wlZ+ueJ93v63a4hv5nkUz5g0zCwe+AVwDbAXWGtmi9x9S9huDwGPu/tjZjYFuB+4zcymA5cAo4EkYIWZveDuVe5+VdhrPEMoUTRa5e4zThPSZHc/EPklto7SyhpyuibHzEyXItJ2JCfGM35wBuMHZ/Dt6aHvo537j7TIbNuR3IIfB2x39x3ufhx4CrixyT7DgFeCx6+GbR8GrHT3Onc/AhQCU8MPNLMuwBRgwTldQRtRXFHbprrFiUjsyk7ryBUtNNt2JEkjF9gT9nxvUBZuAzAneDwbSDWz9KB8qpmlmFkGMBno3eTYWcByd68KK7vczDaY2QtmNjys3IFlZrbOzO44XcBmdoeZFZhZwf79+yO4xPNXUlGj+xki0u41V2ffbwATzewdYCJQDNS7+zJgKbAaeBJYQ+h+RLhbgm2N3gb6uvso4D/5aA1kvLtfAkwD7jSzCacKxt3nuXu+u+dnZmae98WdybG6evZXHyNbPadEpJ2LJGkU89HaQa+g7CR3L3H3Oe4+Bvh2UFYR/L7P3Ue7+zWAAUWNxwW1j3HA82HnqnL3w8HjpUBisB/uXhz83gc8FxwbdeWVxwDUPCUi7V4kSWMtMNjM+ptZB2AusCh8BzPLMLPGc91DqCcVZhYfNFNhZnlAHrAs7NCbgCXuXht2riwL7iab2bggxoNm1snMUoPyTsC1wKazveCWUFIZjNFQ85SItHNn7D3l7nVmdhfwEqEut/PdfbOZ3QsUuPsiYBJwv5k5sBK4Mzg8EVgV5IAqQl1x68JOPxf4SPddQonky2ZWB9QAc93dzawn8FxwrgTgCXd/8VwuurlpYJ+IxIqIxmkEzURLm5R9J+zx08DTpziullAPqtOdd9Ipyn4O/PwU5TuAUZHE29pKGwf2qXlKRNq56M161Y4UV9TQvVMHkhPjox2KiEiLUtJoBiUVNWqaEpGYoKTRDEorajW7rYjEBCWNZlBSUaN1NEQkJihpnKeq2hNUH6sju40uzSgi0pyUNM5TaYV6TolI7FDSOE9/HaOhpCEi7Z+Sxnk6ORpcvadEJAYoaZynkooa4uOMHqlKGiLS/ilpnKfSilqyuiS3yGInIiJtjZLGeSrWwD4RiSFKGueptFID+0QkdihpnIeGBg/WBlfSEJHYoKRxHg4cPsaJeidXzVMiEiOUNM5DSTAlupqnRCRWKGmcBw3sE5FYo6RxHrRin4jEGiWN81BSUUtKh3jSOiZGOxQRkVahpHEeGntOBeuWi4i0exElDTObambbzGy7md19iu19zWy5mRWa2Qoz6xW27UEz2xT83BxWvsrM1gc/JWa2ICifZGaVYdu+E3bMJ8bR2koqajQluojElIQz7WBm8cAvgGuAvcBaM1vk7lvCdnsIeNzdHzOzKcD9wG1mNh24BBgNJAErzOwFd69y96vCXuMZYGHY+Va5+4xziKNVFVfUcnF2l2i9vIhIq4ukpjEO2O7uO9z9OPAUcGOTfYYBrwSPXw3bPgxY6e517n4EKASmhh9oZl2AKcCCZoij1Ryrq+fA4WPqbisiMSWSpJEL7Al7vjcoC7cBmBM8ng2kmll6UD7VzFLMLAOYDPRucuwsYLm7V4WVXW5mG8zsBTMbfhZxtJqyysbFl9Q8JSKxo7luhH8DmGhm7wATgWKg3t2XAUuB1cCTwBqgvsmxtwTbGr0N9HX3UcB/cuYayMeY2R1mVmBmBfv37z/bwyNSohX7RCQGRZI0ivlo7aBXUHaSu5e4+xx3HwN8OyirCH7f5+6j3f0awICixuOC2sc44Pmwc1W5++Hg8VIgMdjvjHGEnWOeu+e7e35mZmYEl3j2NLBPRGJRJEljLTDYzPqbWQdgLrAofAczyzCzxnPdA8wPyuODZirMLA/IA5aFHXoTsMTda8POlWVBH1YzGxfEeDCSOFpTY9JQ7ykRiSVn7D3l7nVmdhfwEhAPzHf3zWZ2L1Dg7ouAScD9ZubASuDO4PBEYFWQA6qAW929Luz0c4EHmrzkTcCXzawOqAHmursDp4zjXC66OZRU1pLeqQPJifHRCkFEpNVZ6Pu4/crPz/eCgoJmP+8X5r/FoSPHWfxP45v93CIi0WRm69w9/1TbNCL8HJVWamCfiMQeJY1zVFJRq5vgIhJzlDTOQVXtCQ4fq9MYDRGJOUoa50DdbUUkVilpnAMlDRGJVUoa5+DkaHDNOyUiMUZJ4xyUVNSQEGdkpiZFOxQRkValpHEOSitr6dklmfg4Lb4kIrFFSeMcFFfUkKv7GSISg5Q0zkFJRQ3Z6m4rIjFISeMs1Tc45VUa2CcisUlJ4ywdOHyME/WupCEiMUlJ4yydHKOheadEJAYpaZwlrdgnIrFMSeMslVY21jSUNEQk9ihpnKXiiho6dYinS8czrl8lItLuKGmcpVB3244EqxGKiMQUJY2zVFqp7rYiEruUNM5SSUUNuRrYJyIxSknjLNSeqOfA4eNk6ya4iMSoiJKGmU01s21mtt3M7j7F9r5mttzMCs1shZn1Ctv2oJltCn5uDitfZWbrg58SM1vQ5JxjzazOzG4KK6sPO2bROV3xeSirVHdbEYltZ+wCZGbxwC+Aa4C9wFozW+TuW8J2ewh43N0fM7MpwP3AbWY2HbgEGA0kASvM7AV3r3L3q8Je4xlgYZPXfBBY1iScGncfffaX2TxKKjWwT0RiWyQ1jXHAdnff4e7HgaeAG5vsMwx4JXj8atj2YcBKd69z9yNAITA1/EAz6wJMARaEFf8T8AywL/JLaXka2CcisS6SpJEL7Al7vjcoC7cBmBM8ng2kmll6UD7VzFLMLAOYDPRucuwsYLm7VwGYWW5wjl+dIpZkMyswszfNbFYEsTerxilEslTTEJEY1Vwj1L4B/NzMbgdWAsVAvbsvM7OxwGpgP7AGqG9y7C3AI2HPfwr8q7s3nGIsRF93LzazAcArZrbR3d9vupOZ3QHcAdCnT5/zvbaTSitryOjcgeTE+GY7p4jIhSSSmkYxH60d9ArKTnL3Enef4+5jgG8HZRXB7/vcfbS7XwMYUNR4XFD7GAc8H3a6fOApM9sF3AT8srFW4e7Fwe8dwApgzKkCdvd57p7v7vmZmZkRXGJkiis0RkNEYlskSWMtMNjM+ptZB2Au8JGeS2aWYWaN57oHmB+UxwfNVJhZHpDHR29u3wQscffaxgJ37+/u/dy9H/A08BV3X2Bm3cwsqfH1gCuB8JvxLa60ooZsNU2JSAw7Y9Jw9zrgLuAl4F3gj+6+2czuNbMbgt0mAdvMrAjoCdwXlCcCq8xsCzAPuDU4X6O5wJMRxnoxUGBmGwjdbH+gSQ+uFuXulFTUqKYhIjEtonsa7r4UWNqk7Dthj58mVCtoelwtoR5UpzvvpDO87u1hj1cDIyOJtyVU1dRx5Hi9ZrcVkZimEeEROjlGQzUNEYlhShoRauxum615p0QkhilpRKgkmEIkVzUNEYlhShoRKqmoITHeyOycFO1QRESiRkkjQqUVNfTskkxcnBZfEpHYpaQRoRIN7BMRUdKIVHFFjWa3FZGYp6QRgfoGp7xKNQ0RESWNCOyvPkZdg5OtpCEiMU5JIwKNA/u0NriIxDoljQg0DuxT85SIxDoljQicHA2ueadEJMYpaUSgpKKWzkkJdElurjWrREQuTEoaESgJ1tE4xUqCIiIxRUkjAqWV6m4rIgJKGhHR4ksiIiFKGmdQe6Keg0eOazS4iAhKGmdUGkyJrpqGiIiSxhlp8SURkb9S0jiDxqShxZdERCJMGmY21cy2mdl2M7v7FNv7mtlyMys0sxVm1its24Nmtin4uTmsfJWZrQ9+SsxsQZNzjjWzOjO7KazsC2b2XvDzhXO64rNUUhFqnsrSPQ0REc44Ws3M4oFfANcAe4G1ZrbI3beE7fYQ8Li7P2ZmU4D7gdvMbDpwCTAaSAJWmNkL7l7l7leFvcYzwMImr/kgsCysrDvwXSAfcGBdEMeH53bpkSmtrCGjcxJJCfEt+TIiIheESGoa44Dt7r7D3Y8DTwE3NtlnGPBK8PjVsO3DgJXuXufuR4BCYGr4gWbWBZgCLAgr/ifgGWBfWNl1wMvufihIFC83PVdLKK6o0USFIiKBSJJGLrAn7PneoCzcBmBO8Hg2kGpm6UH5VDNLMbMMYDLQu8mxs4Dl7l4FYGa5wTl+dQ5xEJzjDjMrMLOC/fv3n/kKP0FpZa3mnBIRCTTXjfBvABPN7B1gIlAM1Lv7MmApsBp4ElgD1Dc59pZgW6OfAv/q7g3nGoy7z3P3fHfPz8zMPNfT4O4a2CciEiaSGfiK+WjtoFdQdpK7lxDUNMysM/AZd68Itt0H3BdsewIoajwuqH2MI1SzaJQPPBXM85QBXG9mdcFrTmoSx4oI4j9nlTUnOHq8nhw1T4mIAJHVNNYCg82sv5l1AOYCi8J3MLMMM2s81z3A/KA8PmimwszygDzCbm4DNwFL3L22scDd+7t7P3fvBzwNfMXdFwAvAdeaWTcz6wZcG5S1mMaeU6ppiIiEnLGm4e51ZnYXoS/oeGC+u282s3uBAndfRKgGcL+ZObASuDM4PBFYFdQaqoBb3b0u7PRzgQciCdTdD5nZDwglMYB73f1QJMeeq7+uo6GahogIRNY8hbsvJXRvIrzsO2GPnyZUK2h6XC2hHlSnO++kM7zu7U2ezyeoxbSG0koN7BMRCacR4Z+guKKWxHgjo3NStEMREWkTlDQ+QUlFDVlpycTFafElERFQ0vhEpZU15GiMhojISUoan6CkQiv2iYiEU9I4jfoGp6yqVmM0RETCKGmcxr7qWuobXFOIiIiEUdI4jcaBfepuKyLyV0oap9E4sE/3NERE/kpJ4zS0zKuIyMcpaZxGaWUtqUkJdElOjHYoIiJthpLGaRRX1KiWISLShJLGaZRWah0NEZGmlDROo6RCK/aJiDSlpHEKDQ3OpCGZjOvfLdqhiIi0KRFNjR5r4uKMn9w8OtphiIi0OappiIhIxJQ0REQkYkoaIiISMSUNERGJmJKGiIhETElDREQipqQhIiIRU9IQEZGImbtHO4YWZWb7gd3neHgGcKAZw7lQ6X0I0fsQovchpD2/D33dPfNUG9p90jgfZlbg7vnRjiPa9D6E6H0I0fsQEqvvg5qnREQkYkoaIiISMSWNTzYv2gG0EXofQvQ+hOh9CInJ90H3NEREJGKqaYiISMSUNEREJGJKGqdgZlPNbJuZbTezu6MdTzSZ2S4z22hm682sINrxtBYzm29m+8xsU1hZdzN72czeC363+6UdT/M+fM/MioPPxHozuz6aMbYGM+ttZq+a2RYz22xmXwvKY+4zoaTRhJnFA78ApgHDgFvMbFh0o4q6ye4+Osb6pD8KTG1Sdjew3N0HA8uD5+3do3z8fQD4j+AzMdrdl7ZyTNFQB/yzuw8DLgPuDL4XYu4zoaTxceOA7e6+w92PA08BN0Y5Jmll7r4SONSk+EbgseDxY8Cs1owpGk7zPsQcdy9197eDx9XAu0AuMfiZUNL4uFxgT9jzvUFZrHJgmZmtM7M7oh1MlPV099LgcRnQM5rBRNldZlYYNF+1+yaZcGbWDxgD/IUY/EwoaciZjHf3Swg1191pZhOiHVBb4KG+6rHaX/1XwEBgNFAK/Diq0bQiM+sMPAN83d2rwrfFymdCSePjioHeYc97BWUxyd2Lg9/7gOcINd/FqnIzywYIfu+LcjxR4e7l7l7v7g3Ar4mRz4SZJRJKGP/j7s8GxTH3mVDS+Li1wGAz629mHYC5wKIoxxQVZtbJzFIbHwPXAps++ah2bRHwheDxF4CFUYwlahq/JAOziYHPhJkZ8BvgXXf/SdimmPtMaET4KQRdCH8KxAPz3f2+6EYUHWY2gFDtAiABeCJW3gszexKYRGj663Lgu8AC4I9AH0LT7X/O3dv1TeLTvA+TCDVNObAL+Mewdv12yczGA6uAjUBDUPwtQvc1YuszoaQhIiKRUvOUiIhETElDREQipqQhIiIRU9IQEZGIKWmIiEjElDRERCRiShoiIhKx/w9gCzLPT7cX5gAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.1880155, G_loss_U: 1.9836206, G_loss_S: 0.00638855, E_loss_t0: 2.2167387\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.7648443, G_loss_U: 1.5885978, G_loss_S: 0.0067279604, E_loss_t0: 2.2251334\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 0.9675709, G_loss_U: 0.44963118, G_loss_S: 0.006931994, E_loss_t0: 2.143197\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.4099841, G_loss_U: 0.3579704, G_loss_S: 0.0077466476, E_loss_t0: 2.2402458\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.545742, G_loss_U: 0.35800633, G_loss_S: 0.008292646, E_loss_t0: 2.2109363\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.5335246, G_loss_U: 0.41396597, G_loss_S: 0.008668523, E_loss_t0: 2.2885988\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.420735, G_loss_U: 0.53916603, G_loss_S: 0.008627192, E_loss_t0: 2.244941\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.2511957, G_loss_U: 0.7641943, G_loss_S: 0.009372782, E_loss_t0: 2.2390673\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.0827955, G_loss_U: 1.0686538, G_loss_S: 0.010239758, E_loss_t0: 2.2099404\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD4CAYAAAAHHSreAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAkSElEQVR4nO3de3Qc5X3/8fdHK8mSsGXL+G7JmMQmQQFhU2GaS4sppTWQ4OBcsHtokzYNaQM5bRInB370R3pIKSGQtr8kNI3buAltAyWkCW5xglMwl8QksQjY2AY7wiHYssHC+H7RZff7+2NH8lqSrfV1Je3ndY7Ozj5z2WfW6/nMPDPPjCICMzOzXCWFroCZmQ08DgczM+vF4WBmZr04HMzMrBeHg5mZ9VJa6AqcDGPGjImpU6cWuhpmZoPKM88883pEjO1r3JAIh6lTp9LU1FToapiZDSqSfn2kcW5WMjOzXhwOZmbWi8PBzMx6cTiYmVkvDgczM+vF4WBmZr04HMzMrJeiDoeVL7/BnT98Ed+23MzscEUdDs9v3sXXHn+JHfs7Cl0VM7MBpajDobamEoBNb+wvcE3MzAaWog6HutFVAGzecaDANTEzG1iKOhy6jxx2+MjBzCxXUYfDiIoyRlWVsdnhYGZ2mKIOB8gePWx6w81KZma5ij4c6mqq3KxkZtZD0YdDbU0lLTsOuK+DmVmOog+HutFVtHVmaN3TVuiqmJkNGHmFg6Q5ktZLapZ0Ux/jz5L0qKTVkh6XVJsz7k5Ja5K/a/uY98uS9ua8nyJpuaRnk+Vdebwrl49DVyz5vIOZWZd+w0FSCrgHuAKoBxZIqu8x2d3AvRHRANwG3JHMexVwITADuBhYKKk6Z9mNQE2PZf0V8EBEzATmA/947KuVv7qarr4OPu9gZtYlnyOHWUBzRGyMiHbgfmBuj2nqgceS4eU54+uBJyOiMyL2AauBOdAdOncBn+2xrAC6AmQksCX/1Tl2k5MjB3eEMzM7JJ9wmAxsynm/OSnLtQqYlwxfA4yQdGZSPkdSlaQxwKVAXTLdjcCSiNjaY1l/DVwnaTOwFPhEnutyXKrKSxkzvNy30DAzy3GyTkgvBC6R9CxwCdACpCNiGdkN/ArgPuBpIC1pEvAB4Ct9LGsB8M2IqAWuBP5NUq96SrpeUpOkptbW1hOq/OSaKh85mJnlyCccWji0tw9Qm5R1i4gtETEvOU9wS1K2M3m9PSJmRMTlgIANwExgGtAs6WWgSlJzsriPAA8k8z4NVABjelYqIhZFRGNENI4dOzbP1e1bXU2l+zqYmeXIJxxWAtMlnS2pnOxJ4iW5E0gak7N3fzOwOClPJc1LSGoAGoBlEfFwREyIiKkRMRXYHxHTkvlfAS5L5jmXbDic2KFBP+pGV7Fl5wHSGfd1MDMDKO1vgojolHQj8AiQAhZHxFpJtwFNEbEEmA3cISmAJ4EbktnLgKckAewGrouIzn4+8tPAP0v6JNmT0x+OU9xDrbamko508Nrug0waVXkqP8rMbFDoNxwAImIp2XMHuWW35gw/CDzYx3wHyV6x1N/yh+cMrwPemU+9TpZDl7MecDiYmeEe0oAf+mNm1pPDAfd1MDPryeEADCtNMb56mK9YMjNLOBwSdTVVvoWGmVnC4ZDwQ3/MzA5xOCTqRlexddcBOtKZQlfFzKzgHA6J2ppKMgGv7jpY6KqYmRWcwyHR1dfBl7OamTkcutXmdIQzMyt2DofExFEVlAhfzmpmhsOhW1mqhIkjK33kYGaGw+Ew2ctZfeRgZuZwyFHrh/6YmQEOh8PUja7ktT0HaetMF7oqZmYF5XDIUVtTRQRs2em+DmZW3BwOOep8624zM8DhcJja0e7rYGYGDofDTKiuoLRE7utgZkXP4ZAjVSImjXJfBzMzh0MPdaPd18HMLK9wkDRH0npJzZJu6mP8WZIelbRa0uOSanPG3SlpTfJ3bR/zflnS3h5lH5S0TtJaSd8+nhU7XnXu62BmRml/E0hKAfcAlwObgZWSlkTEupzJ7gbujYhvSfod4A7gDyVdBVwIzACGAY9L+kFE7E6W3QjU9Pi86cDNwDsjYoekcSe6kseitqaS1/e2caA9TWV56nR+tJnZgJHPkcMsoDkiNkZEO3A/MLfHNPXAY8nw8pzx9cCTEdEZEfuA1cAc6A6du4DP9ljWR4F7ImIHQERsO7ZVOjF13VcsuWnJzIpXPuEwGdiU835zUpZrFTAvGb4GGCHpzKR8jqQqSWOAS4G6ZLobgSURsbXHss4BzpH0E0k/lTSnr0pJul5Sk6Sm1tbWPFYjP7VJXwc3LZlZMeu3WSlPC4GvSvow8CTQAqQjYpmki4AVQCvwNJCWNAn4ADD7CHWanoyrBZ6UdH5E7MydKCIWAYsAGhsb4yStx6GH/vjIwcyKWD5HDi0c2tuH7Aa7JXeCiNgSEfMiYiZwS1K2M3m9PSJmRMTlgIANwExgGtAs6WWgSlJzsrjNZI8oOiLiV8n0049z/Y7ZmOHDKC8t8ZGDmRW1fMJhJTBd0tmSyoH5wJLcCSSNkdS1rJuBxUl5KmleQlID0AAsi4iHI2JCREyNiKnA/oiYlsz/fZIjiqQp6hxg4/Gv4rEpKZFv3W1mRa/fZqWI6JR0I/AIkAIWR8RaSbcBTRGxhOzG/A5JQbZZ6YZk9jLgKUkAu4HrIqKzn498BPg9SeuANPCZiNh+7Kt2/HzrbjMrdnmdc4iIpcDSHmW35gw/CDzYx3wHyV6x1N/yh+cMB/Cp5K8g6moqWb15Z6E+3sys4NxDug+1NVXs3N/BnoMdha6KmVlBOBz6UDfal7OaWXFzOPShtsa37jaz4uZw6IMf+mNmxc7h0IfRZ5RTWZbykYOZFS2HQx8kZW/d7V7SZlakHA5H4L4OZlbMHA5HUFdTyeY39pPtdmFmVlwcDkdQW1PFnrZOdh/or0O3mdnQ43A4gq6+Dj7vYGbFyOFwBF19HXw5q5kVI4fDEdS5I5yZFTGHwxGMrCpjREWpm5XMrCg5HI7Cl7OaWbFyOBxFnR/6Y2ZFyuFwFF1HDu7rYGbFxuFwFHWjKznQkWb7vvZCV8XM7LRyOByFb91tZsXK4XAU3R3hfN7BzIpMXuEgaY6k9ZKaJd3Ux/izJD0qabWkxyXV5oy7U9Ka5O/aPub9sqS9fZS/T1JIajzWlTpZfORgZsWq33CQlALuAa4A6oEFkup7THY3cG9ENAC3AXck814FXAjMAC4GFkqqzll2I1DTx2eOAP4C+Nmxr9LJM3xYKTVVZe7rYGZFJ58jh1lAc0RsjIh24H5gbo9p6oHHkuHlOePrgScjojMi9gGrgTnQHTp3AZ/t4zM/D9wJHDyGdTkl3NfBzIpRPuEwGdiU835zUpZrFTAvGb4GGCHpzKR8jqQqSWOAS4G6ZLobgSURsTV3QZIuBOoi4uGjVUrS9ZKaJDW1trbmsRrHp2509tbdZmbF5GSdkF4IXCLpWeASoAVIR8QyYCmwArgPeBpIS5oEfAD4Su5CJJUAfwd8ur8PjIhFEdEYEY1jx449SavRW21NFZt3HiCTcV8HMyse+YRDC4f29gFqk7JuEbElIuZFxEzglqRsZ/J6e0TMiIjLAQEbgJnANKBZ0stAlaRmYARwHvB4Uv6bwJJCnpSuq6mkvTND6962QlXBzOy0K81jmpXAdElnkw2F+cAf5E6QNBm9EREZ4GZgcVKeAkZFxHZJDUADsCwiOoEJOfPvjYhpydsxOeWPAwsjouk41++EHbpiaT/jqysKVQ0zs9Oq3yOHZEN+I/AI8ALwQESslXSbpKuTyWYD6yVtAMYDtyflZcBTktYBi4DrkuUNGof6OviktJkVj3yOHIiIpWTPHeSW3Zoz/CDwYB/zHSR7xVJ/yx9+hPLZ+dTvVJo8yg/9MbPi4x7S/agsTzFm+DBfzmpmRcXhkIfamkp3hDOzouJwyEPdaHeEM7Pi4nDIQ21NJVt2HiDtvg5mViQcDnmoq6miMxO8urvgd/MwMzstHA55qK3xrbvNrLg4HPJQN9q37jaz4uJwyMOkURVIPnIws+LhcMjDsNIU40dU+MjBzIqGwyFPdaPd18HMiofDIU+1NVW0+MjBzIqEwyFPdTWVbN11gI50ptBVMTM75RwOeaqtqSITsHWn+zqY2dDncMhTbdetu33ewcyKgMMhT3U5D/0xMxvqHA55mjiyglSJ/NAfMysKDoc8laZKmFBd4WYlMysKDodjUDe60h3hzKwoOByOQW1NlW+hYWZFweFwDOpqqti2p42DHelCV8XM7JTKKxwkzZG0XlKzpJv6GH+WpEclrZb0uKTanHF3SlqT/F3bx7xflrQ35/2nJK1LlvWopLOOd+VOtq5bd7fsdNOSmQ1t/YaDpBRwD3AFUA8skFTfY7K7gXsjogG4Dbgjmfcq4EJgBnAxsFBSdc6yG4GaHst6FmhMlvUg8MVjX61Tw7fuNrNikc+RwyygOSI2RkQ7cD8wt8c09cBjyfDynPH1wJMR0RkR+4DVwBzoDp27gM/mLigilkdEV8P+T4FaBgg/9MfMikU+4TAZ2JTzfnNSlmsVMC8ZvgYYIenMpHyOpCpJY4BLgbpkuhuBJRGx9Sif/RHgB32NkHS9pCZJTa2trXmsxokbX11BWUo+cjCzIa/0JC1nIfBVSR8GngRagHRELJN0EbACaAWeBtKSJgEfAGYfaYGSrgMagUv6Gh8Ri4BFAI2NjXGS1uOoUiVi0ijfutvMhr58jhxaOLS3D9lmnpbcCSJiS0TMi4iZwC1J2c7k9faImBERlwMCNgAzgWlAs6SXgSpJzV3Lk/S7yXKujoi241y3U6KupspHDmY25OVz5LASmC7pbLKhMB/4g9wJkiajNyIiA9wMLE7KU8CoiNguqQFoAJZFRCcwIWf+vRExLRmeCXwdmBMR2050BU+22ppKfrTutUJXw8zslOo3HCKiU9KNwCNAClgcEWsl3QY0RcQSss1Dd0gKss1KNySzlwFPSQLYDVyXBMPR3AUMB76TzPdKRFx9zGt2itSNrmL7vnb2t3dSVX6yWuXMzAaWvLZuEbEUWNqj7Nac4QfJXnbac76DZK9Y6m/5w3OGfzefOhVK1xVLm3cc4JzxIwpcGzOzU8M9pI/RWydku2n83++vYfveAXU6xMzspHE4HKO3TBjB3197Ac9u2snVX/0Ja7fsKnSVzMxOOofDcbhmZi3f+djbSWeC93/taR5efbSuGmZmg4/D4ThdUDeKJZ94J/WTqrnh27/grkdeJJM5Ld0tzMxOOYfDCRg3ooJvf/Rirm2s457lL/HRe5vYfbCj0NUyMzthDocTNKw0xRfedz63zX0bj29o5Zp7fsLG1r39z2hmNoA5HE4CSfzR26fy7x+5mB37O5h7z094fP2A679nZpY3h8NJ9PY3n8lDN7yT2poq/vibK/mnJ14iwuchzGzwcTicZHWjq/jun7+dK8+byBd+8CJ/+Z/P+clxZjboOBxOgaryUr76BzP5zO+/hSWrtvD+f1rhp8eZ2aDicDhFJHHDpdP4lz9q5OXX9zP3qz92hzkzGzQcDqfYZeeO5/s3vIMI+NKyDYWujplZXhwOp8G0cSOYP6uOx9dvY4ubl8xsEHA4nCbzL5pCJuCBpk39T2xmVmAOh9OkbnQVvzV9DA+s3ETat9kwswHO4XAaLZg1hS27DvLkhtZCV8XM7KgcDqfR7547njPPKOe+n79S6KqYmR2Vw+E0Ki8t4f2NtTz64ja27T5Y6OqYmR2Rw+E0m3/RFNKZ4DvPbC50VczMjiivcJA0R9J6Sc2Sbupj/FmSHpW0WtLjkmpzxt0paU3yd20f835Z0t6c98Mk/WfyWT+TNPU4121AOnvMGbz9TWdy/8pX/PwHMxuw+g0HSSngHuAKoB5YIKm+x2R3A/dGRANwG3BHMu9VwIXADOBiYKGk6pxlNwI1PZb1EWBHREwD/h6489hXa2CbP6uOTW8c4CcvvV7oqpiZ9SmfI4dZQHNEbIyIduB+YG6PaeqBx5Lh5Tnj64EnI6IzIvYBq4E50B06dwGf7bGsucC3kuEHgcskKf9VGvh+/20TqKkq84lpMxuw8gmHyUBuz63NSVmuVcC8ZPgaYISkM5PyOZKqJI0BLgXqkuluBJZERM8HMHd/XkR0AruAM3tWStL1kpokNbW2Dq5LQyvKUsy7sJZla1+jdU9boatjZtbLyTohvRC4RNKzwCVAC5COiGXAUmAFcB/wNJCWNAn4APCV4/3AiFgUEY0R0Th27NgTXoHTbcGsOjozwXd/4RPTZjbw5BMOLRza2weoTcq6RcSWiJgXETOBW5Kyncnr7RExIyIuBwRsAGYC04BmSS8DVZKae36epFJgJLD9uNZuAJs2bgQXTa3h/p+/4gcCmdmAk084rASmSzpbUjkwH1iSO4GkMZK6lnUzsDgpTyXNS0hqABqAZRHxcERMiIipETEV2J+cgCZZ9oeS4fcDj8UQ3XoumDWFl7fv5+mNQy77zGyQ6zccknb/G4FHgBeAByJiraTbJF2dTDYbWC9pAzAeuD0pLwOekrQOWARclyzvaL4BnJkcSXwK6HXp7FBx5fkTqa4o5f6f+2Z8ZjawlOYzUUQsJXvuILfs1pzhB8leWdRzvoNkr1jqb/nDe8zzgXzqNdh1nZj+9s9eYce+dmrOKC90lczMAPeQLrj5s+poT2d8YtrMBhSHQ4G9dUI1M6eM4v6Vm3xi2swGDIfDALDgoik0b9tL0693FLoqZmaAw2FAePcFExk+rNQ9ps1swHA4DABV5aXMnTGJh1dvZdf+jkJXx8zM4TBQLJg1hbbODN9/rqX/ic3MTjGHwwBx3uSRnD95JPe5x7SZDQAOhwFkwawpvPjqHp7btLPQVTGzIudwGECunjGJqvKUT0ybWcE5HAaQ4cNKufqCSfz3qq3sOegT02ZWOA6HAWb+rCkc6Ejz0HNbCl0VMytiDocB5oLakZw7sZr7V7ppycwKx+EwwEhiwaw61rTs5vnNuwpdHTMrUg6HAWjujMlUlJVwn48ezKxAHA4D0MjKMt7dMImHnm1hX1t/j78wMzv5HA4D1IJZdexrT/M/q31i2sxOP4fDAHXhlBrOGT+cRU9upK0zXejqmFmRcTgMUJK4+Ypzeal1H19/YmOhq2NmRcbhMIBd+tZxvLthIl99rJmXWvcWujpmVkTyCgdJcyStl9Qs6aY+xp8l6VFJqyU9Lqk2Z9ydktYkf9fmlH9D0qpkngclDU/Kp0haLunZZNyVJ2NFB6tb31NPRVkJt3zved+Qz8xOm37DQVIKuAe4AqgHFkiq7zHZ3cC9EdEA3Abckcx7FXAhMAO4GFgoqTqZ55MRcUEyzyvAjUn5XwEPRMRMYD7wj8e/eoPfuBEV3Hzlufx04xt85xk/Z9rMTo98jhxmAc0RsTEi2oH7gbk9pqkHHkuGl+eMrweejIjOiNgHrAbmAETEbgBJAiqBrt3iALoCZCRQ9JfrXNtYx6ypo7n94Rd4fW9boatjZkUgn3CYDGzKeb85Kcu1CpiXDF8DjJB0ZlI+R1KVpDHApUBd10yS/hV4FXgr8JWk+K+B6yRtBpYCn+irUpKul9Qkqam1tTWP1Ri8SkrE3847jwPtaT7/P+sKXR0zKwIn64T0QuASSc8ClwAtQDoilpHdwK8A7gOeBrqvy4yIPwYmAS8AXecjFgDfjIha4Erg3yT1qmdELIqIxohoHDt27ElajYFr2rgR/PnsN/PQc1t4YsPQDkMzK7x8wqGFnL19oDYp6xYRWyJiXnKe4JakbGfyentEzIiIywEBG3rMmybbVPW+pOgjwAPJuKeBCmDMsa3W0PTxS9/Mm8aewS3fe5797e45bWanTj7hsBKYLulsSeVkTxIvyZ1A0picvfubgcVJeSppXkJSA9AALFPWtKRcwNXAi8n8rwCXJePOJRsO3lUGhpWmuOOa89m84wD/739/WejqmNkQ1m84REQn2SuJHiHb/PNARKyVdJukq5PJZgPrJW0AxgO3J+VlwFOS1gGLgOuS5Qn4lqTngeeBiWSvcgL4NPBRSavINkV9OHwNZ7eL33Qm8y+q419+/CvWbvFdW83s1NBQ2O42NjZGU1NToatx2uza38Flf/cEk0ZV8L2Pv5NUiQpdJTMbhCQ9ExGNfY1zD+lBaGRVGZ97Tz2rN+/iWyteLnR1zGwIcjgMUu9umMjst4zl7mXradl5oNDVMbMhxuEwSEni83PPIwI+99Aa31rDzE4qh8MgVje6ik//3jn87wvb+OGaVwtdHTMbQhwOg9yH3zGV8yZX87kla9l1oKPQ1TGzIcLhMMiVpkq445oGXt/bxhd/+GL/M5iZ5cHhMAScXzuSP3nn2fzHz16h6eU3Cl0dMxsCHA5DxCcvP4fJoyq5+b+ep70zU+jqmNkg53AYIs4YVsrfvPc8frltL19/4qVCV8fMBjmHwxDS9VjRf3j0l3zXDwYysxNQWugK2Mn1hfc1sGN/O5/+zipa97bxsd9+E9l7G5qZ5c9HDkPM8GGlLP7wRby7YSJf+MGLfP5/XiCTcQc5Mzs2PnIYgoaVpvjy/JmMGT6MxT/5Fa/vbePuD1xAean3BcwsPw6HIaqkRHzuPfWMqx7GF3+4nh372/nadb/B8GH+Jzez/nlXcgiTxMdnT+OL729gxUvbWbDop7y+t63Q1TKzQcDhUAQ+2FjHoj/8DX65bQ/v/9oKXtm+v9BVMrMBzuFQJC47dzz/8ae/yc4DHcz72go/Rc7MjsrhUER+46waHvyzt1OeEtd+/aeseOn1QlfJzAYoh0ORmTZuBN/9+DuYNKqCDy9eycOrtxa6SmY2ADkcitDEkZV852PvoKF2JDfe9wvuffrlQlfJzAaYvMJB0hxJ6yU1S7qpj/FnSXpU0mpJj0uqzRl3p6Q1yd+1OeXfkLQqmedBScNzxn1Q0jpJayV9+0RX0nobWVXGv//pxVz21vHc+tBa7n5kPWl3ljOzRL/hICkF3ANcAdQDCyTV95jsbuDeiGgAbgPuSOa9CrgQmAFcDCyUVJ3M88mIuCCZ5xXgxmSe6cDNwDsj4m3AX57ICtqRVZSl+KfrLmT+RXV8dXkzV335KZ7Y0OpHjppZXkcOs4DmiNgYEe3A/cDcHtPUA48lw8tzxtcDT0ZEZ0TsA1YDcwAiYjeAsjf+qQS6tkgfBe6JiB3JdNuOZ8UsP6WpEu6Ydz5fWTCTfe2dfGjxz/nDb/ycNS2+msmsmOUTDpOBTTnvNydluVYB85Lha4ARks5MyudIqpI0BrgUqOuaSdK/Aq8CbwW+khSfA5wj6SeSfippTl+VknS9pCZJTa2trXmshh2JJN5zwST+91OXcOu761mzZRfv/sqP+eR/PsfmHe4TYVaMTtYJ6YXAJZKeBS4BWoB0RCwDlgIrgPuAp4F010wR8cfAJOAFoOt8RCkwHZgNLAD+WdKonh8YEYsiojEiGseOHXuSVqO4DStN8SfvOpsnPnMpf3bJm3n4+a38zpee4I6lL7Brv59PbVZM8gmHFnL29oHapKxbRGyJiHkRMRO4JSnbmbzeHhEzIuJyQMCGHvOmyTZVvS8p2gwsiYiOiPhVMv30Y10xO34jK8u46Yq3snzhbN7TMIlFT23kt+9azr88tZG2znT/CzCzQS+fcFgJTJd0tqRyYD6wJHcCSWMkdS3rZmBxUp5KmpeQ1AA0AMuUNS0pF3A18GIy//fJHjWQNEWdA2w83hW04zd5VCVf+uAFPPyJ3+KCulH8zcMvcNmXnuCh51p8G3CzIa7fcIiITrJXEj1CtvnngYhYK+k2SVcnk80G1kvaAIwHbk/Ky4CnJK0DFgHXJcsT8C1JzwPPAxPJXuVE8jnbk3mWA5+JiO0nvqp2vOonVXPvn8zi3z4yi+qKMv7i/ue4+p4fs6LZPazNhioNhcsWGxsbo6mpqdDVKAqZTPDQqhbufmQDLTsP8JbxI7ji/Alcef5Epo8b7qfOmQ0ikp6JiMY+xzkc7Hgc7EjznaZN/Peqraz89RtEwJvGnsGV503kivMnUD+x2kFhNsA5HOyU2rbnII+sfY0fPL+Vn27cTibgrDOrmHPeBK48byINtSMdFGYDkMPBTpvte9v40brXWLrmVVY0v05nJpg8qpIrzpvAFedPYGZdDSUlDgqzgcDhYAWxc387P1r3Gj9c8ypP/fJ12tMZxlcP413TxvK2SdW8bVI1506qprqirNBVNStKDgcruN0HO3jshW38YM1Wnvn1zsMeVzpldFV3WNRPquZtk0YybsQwN0WZnWJHCwc/bd5Oi+qKMt47czLvnZm988q2PQdZu2U365K/tVt28YM1r3ZPP2Z4OedOzAbF2yZVM338cMaPqGBUVZlDwwa9TCbY35Fmf1sn+9rT7Gvr5EBHms50EBGkI8hEdrpMBOnkNRPkDAeZDMyYMoo3jx3e/4ceI4eDFcS4ERWMe0sFl75lXHfZnoMdvPjqHta27MoGx9bdfOPHG+lIHzq6LUuJscOHMba6gnEjhiV/FYztGq7Ovh8zvJzSlB9XUozSmaAjnaEjnaEzHXRkMnSkg850hgMdafa3pzmQs0He3578tXWyvyM7bn97dqN9oD1NOhOUCEokJJEqyQ5n30OqJGc4KU9HZJfRll3W3uS16/3+9pN3p4G/ee95Dgcb2kZUlHHR1NFcNHV0d1l7Z4ZfbtvDr17fx7bdbWzb08a2PQdp3dPGpjf288yvd/DGvvZey5JgVGUZFWUphpWWMKw0RXlpSXa4rITyVLase7gseV9aQmVZiqphpVSVp6gqT3FGeTI8rJQzylNUdpUNS1GeKinokUwmE7SnM7R1ZGhLp2nvzNDWmTnstSOdIbf1uKu6h9VauYPZN5nIbmSzG9ugM3NoOJ2zwe3MBJ2Z7N5tZzrZ683kvGYOL0tnOHx8ZOfvTD6rM1nO4Z93qC7pTHaD35nuCoHsvB3JNCfSUl6WUvbfP/n3rSpPkSopIaJrD57u4dw9+649+kiGS0T37+WMYaVMHlXOGcOyyx2evB56n/19VZanSJUoGzBJ4JTkhE+JlAzTPT4lUXPGqTln53CwAa28tCRpWhp5xGnaOzO8vjcbHK1JeGzb3cb2fW20dWQObTw7093Duw90JhvQNG05G9KDHWk6j+HWIKkSUVWeoixVQomyd7gVdP/HVrJHWdLjVWTHRUT2XvWRvWd91/sICCL7mlSnq7mhPalre7JhHIhyN2q5G7xDZRxWVloiSktKSJWIslRSliqhLFVCRZkoS+WOK0mmF2WlJZTlTFuWyi6nNCXKU9nX0lQJ5Ul5ZbIRruoRAFVlpVSWZ3cgLMvhYINeeWkJk0ZVMmlU5UlZXntnJtu00HF4M0BXs8CB9jT7epR1ZrJ7rJlINvBB9x5l10Y+E4e/BpHdS88Ji+zr4e+z47vChcOOgsqTv8OOjEoPHQ2Vp1KUpdR9+XBu0HTJjZfu8QQpdW10lWyYkw10svEtTTbK3cPJxr0rFG1wcziY9dC1wR2JL7G14uVjKDMz68XhYGZmvTgczMysF4eDmZn14nAwM7NeHA5mZtaLw8HMzHpxOJiZWS9D4pbdklqBXx/n7GOA109idQYrfw+H+LvI8veQNZS/h7MiYmxfI4ZEOJwISU1Hup95MfH3cIi/iyx/D1nF+j24WcnMzHpxOJiZWS8OB1hU6AoMEP4eDvF3keXvIasov4eiP+dgZma9+cjBzMx6cTiYmVkvRR0OkuZIWi+pWdJNha5PoUh6WdLzkp6T1FTo+pwukhZL2iZpTU7ZaEk/kvTL5LWmkHU8XY7wXfy1pJbkd/GcpCsLWcdTTVKdpOWS1klaK+kvkvKi/E0UbThISgH3AFcA9cACSfWFrVVBXRoRM4rseu5vAnN6lN0EPBoR04FHk/fF4Jv0/i4A/j75XcyIiKWnuU6nWyfw6YioB34TuCHZJhTlb6JowwGYBTRHxMaIaAfuB+YWuE52GkXEk8AbPYrnAt9Khr8FvPd01qlQjvBdFJWI2BoRv0iG9wAvAJMp0t9EMYfDZGBTzvvNSVkxCmCZpGckXV/oyhTY+IjYmgy/CowvZGUGgBslrU6anYqiOQVA0lRgJvAzivQ3UczhYIe8KyIuJNvEdoOk3y50hQaCyF7nXczXen8NeDMwA9gKfKmgtTlNJA0Hvgv8ZUTszh1XTL+JYg6HFqAu531tUlZ0IqIled0GfI9sk1uxek3SRIDkdVuB61MwEfFaRKQjIgP8M0Xwu5BURjYY/iMi/ispLsrfRDGHw0pguqSzJZUD84ElBa7TaSfpDEkjuoaB3wPWHH2uIW0J8KFk+EPAQwWsS0F1bRAT1zDEfxeSBHwDeCEi/i5nVFH+Joq6h3Ryad4/AClgcUTcXtganX6S3kT2aAGgFPh2sXwPku4DZpO9JfNrwOeA7wMPAFPI3gb+gxEx5E/UHuG7mE22SSmAl4GP5bS9DzmS3gU8BTwPZJLi/0P2vEPx/SaKORzMzKxvxdysZGZmR+BwMDOzXhwOZmbWi8PBzMx6cTiYmVkvDgczM+vF4WBmZr38f9KeXdrXBDI/AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 0.9994486, G_loss_U: 1.3688612, G_loss_S: 0.010945619, E_loss_t0: 2.1248019\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAD4CAYAAAAQP7oXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAm0UlEQVR4nO3de5hddX3v8fdn9uyZySQzScgkM4RgEiCKUUJCR6jFY4KIBtEgqAU8eNTqwSqctiqnB+pztA99eJCC1VaxhWosnFpQ6cW0jRLLxVABJRQSrsEIKIRLAiGE3Oay9/f8sX6TrAyTzM5kkj0z+/N6nv3stX7r9lubYX2yfuvyU0RgZmZWibpqV8DMzEYPh4aZmVXMoWFmZhVzaJiZWcUcGmZmVrH6alfgYGtra4tZs2ZVuxpmZqPGfffd92JETB1o2pgPjVmzZrFq1apqV8PMbNSQ9Ou9TXPzlJmZVcyhYWZmFXNomJlZxRwaZmZWMYeGmZlVzKFhZmYVc2iYmVnFHBoDKJeDb9z2S1Y+vrHaVTEzG1EcGgOoqxPXrnyC2x7bUO2qmJmNKA6NvWhvbeL5V3ZWuxpmZiOKQ2MvOlqbeOFVh4aZWZ5DYy+mtTbygs80zMz24NDYi47WJja82kW57D7Uzcz6ODT2or21id5y8NK27mpXxcxsxHBo7EV7axMAL2xxE5WZWR+Hxl60tzYCDg0zszyHxl50TOw70+iqck3MzEaOikJD0mJJayWtk3TJANNnSrpV0hpJd0iakZt2paSH0uecAZb9K0lbc+Ofk/RIWtetkmbmppUkPZA+y/Z/dyvXNqERyWcaZmZ5g4aGpAJwDXA6MBc4T9LcfrNdDdwQEfOAy4Ar0rJnACcA84GTgIsltebW3QlM7reu+4HOtK6bgT/PTdsREfPTZ0nFezkExUIdbRMaHRpmZjmVnGmcCKyLiCciohu4CTiz3zxzgdvS8O256XOBlRHRGxHbgDXAYtgVRlcBf5xfUUTcHhHb0+g9wAyqpL3VoWFmlldJaBwBPJ0bfyaV5a0Gzk7DZwEtkqak8sWSmiW1AacAR6b5LgKWRcRz+9j2J4Af5cabJK2SdI+k9+9tIUkXpPlWbdw49JcOtrc08byvaZiZ7VI/TOu5GPiGpI8BK4H1QCkiVkh6C3AXsBG4GyhJmg58CFi0txVKOh/oBBbmimdGxHpJRwG3SXowIn7Vf9mIuA64DqCzs3PIT+e1T2zigac3D3VxM7Mxp5IzjfXsPjuArLlofX6GiHg2Is6OiAXAF1LZ5vR9eboGcRog4HFgAXAMsE7SU0CzpHV965P0zrSeJRHRldvO+vT9BHBHWs9B097SxEvbuunqLR3MzZiZjRqVhMa9wBxJsyU1AOcCe9y5JKlNUt+6LgWWpvJCaqZC0jxgHrAiIv49IjoiYlZEzAK2R8Qxab4FwLVkgbEht43Jkhr7tgecDDwy1B2vRMfE7FmNja+6icrMDCponoqIXkkXAbcABWBpRDws6TJgVUQsI2tmukJSkDVPXZgWLwJ3SgLYApwfEb2DbPIqYALwg7Tcb9KdUm8ErpVUJgu7L0fEQQ2NabmnwmdMbj6YmzIzGxUquqYREcuB5f3Kvpgbvpns9tj+y+0ku4NqsPVPyA2/cy/z3AUcV0l9h0tHqx/wMzPL8xPh+9D3/il3xmRmlnFo7MPk5iINhTp3xmRmljg09kGSO2MyM8txaAyio7XJ1zTMzBKHxiDaW5v8KhEzs8ShMQiHhpnZbg6NQbS3NrKtu8TWrsEeLzEzG/scGoPo64zJt92amTk0BjWtJQuNDW6iMjNzaAxm15mGQ8PMzKExmGkt2UsLfdutmZlDY1DjG+tpaaz3HVRmZjg0KtI+0bfdmpmBQ6Mi7a2NvqZhZoZDoyLtrU1s8DUNMzOHRiX6ngovl4fc3biZ2Zjg0KhAR2sTveVg0/bualfFzKyqKgoNSYslrZW0TtIlA0yfKelWSWsk3SFpRm7alZIeSp9zBlj2ryRtzY03Svpe2tbPJc3KTbs0la+V9O793tsham/Nbrv1U+FmVusGDQ1JBeAa4HSyrlvPk9S/C9ergRsiYh5wGXBFWvYM4ARgPnAScLGk1ty6O4HJ/db1CeDliDgG+CpwZZp3LnAu8CZgMfDNVLeDrq8Hvw3ujMnMalwlZxonAusi4omI6AZuAs7sN89c4LY0fHtu+lxgZUT0RsQ2YA3ZAb8vjK4C/rjfus4Erk/DNwOnSlIqvykiuiLiSWBdqttBt7vbV18MN7PaVkloHAE8nRt/JpXlrQbOTsNnAS2SpqTyxZKaJbUBpwBHpvkuApZFxHN7215E9AKvAFMqrAcAki6QtErSqo0bN1awi/s2taURCT+rYWY1b7guhF8MLJR0P7AQWA+UImIFsBy4C7gRuBsoSZoOfAj4+jBtfw8RcV1EdEZE59SpUw94fcVCHVPGNzo0zKzmVRIa69l9dgAwI5XtEhHPRsTZEbEA+EIq25y+L4+I+RFxGiDgcWABcAywTtJTQLOkdf23J6kemAi8VEk9DqaOiQ4NM7NKQuNeYI6k2ZIayC5GL8vPIKlNUt+6LgWWpvJCaqZC0jxgHrAiIv49IjoiYlZEzAK2pwvfpHV/NA1/ELgtIiKVn5vurpoNzAF+MbTd3n/tLe4r3MysfrAZIqJX0kXALUABWBoRD0u6DFgVEcuARcAVkgJYCVyYFi8Cd2bXsdkCnJ+uU+zLt4H/l848NpGFFGmb3wceAXqBCyOitF97ewDaJzbxwNObD9XmzMxGpEFDAyAilpNdm8iXfTE3fDPZnU79l9tJdgfVYOuf0G+ZD+1lvsuByyup83Brb2nipW3ddPeWaaj3M5FmVpt89KtQx8TsAT8/q2FmtcyhUaFp6VkNX9cws1rm0KhQx67Q8JmGmdUuh0aF2h0aZmYOjUpNbi7SUKhzZ0xmVtMcGhWSxLTWRnfGZGY1zaGxH9pbm/x6dDOraQ6N/dDR2sQLvuXWzGqYQ2M/TGtt5AWfaZhZDXNo7IeO1ia2dZfY2jXYm1DMzMYmh8Z+2N0Zk882zKw2OTT2w65uX33brZnVKIfGfmhvzd4/5YvhZlarHBr7wX2Fm1mtc2jsh/GN9bQ01vtVImZWsxwa+6l9YpNDw8xqlkNjP7W3uq9wM6tdFYWGpMWS1kpaJ+mSAabPlHSrpDWS7pA0IzftSkkPpc85ufJvS1qdlrlZ0oRU/lVJD6TP45I255Yp5abt0U/5odLe6r7Czax2Ddrdq6QCcA1wGvAMcK+kZRHxSG62q4EbIuJ6Se8ArgA+IukM4ARgPtAI3CHpRxGxBfhs+kbSXwAXAV+OiM/mtv2/gAW57eyIiPlD3tth0N7axIZXd1IuB3V1qmZVzMwOuUrONE4E1kXEExHRDdwEnNlvnrnAbWn49tz0ucDKiOiNiG3AGmAxQC4wBIwDYoBtnwfcWPnuHHwdrU30lIJN27urXRUzs0OuktA4Ang6N/5MKstbDZydhs8CWiRNSeWLJTVLagNOAY7sW0jSd4DngWOBr+dXKGkmMJvdYQTQJGmVpHskvb+Cug+7Xc9q+LqGmdWg4boQfjGwUNL9wEJgPVCKiBXAcuAusjOGu4FS30IR8XFgOvAocE6/dZ4L3BwRpVzZzIjoBD4MfE3S0QNVRtIFKVxWbdy4cVh2sI978DOzWlZJaKwnd3YAzEhlu0TEsxFxdkQsAL6Qyjan78sjYn5EnAYIeLzfsiWyJq8P9NvuufRrmoqI9en7CeAO9rzekZ/vuojojIjOqVOnVrCLldsdGr4Ybma1p5LQuBeYI2m2pAayg/kedy5JapPUt65LgaWpvJCaqZA0D5gHrFDmmFQuYAnwWG59xwKTyc5M+somS2rs2x5wMpC/GH9ITG1pRPJLC82sNg1691RE9Eq6CLgFKABLI+JhSZcBqyJiGbAIuEJSACuBC9PiReDOLBfYApyf1lcHXC+plezsYzXw6dxmzwVuioj8xfE3AtdKKpOF3Zf73cF1SBQLdUwZ38gGv3/KzGrQoKEBEBHLya5N5Mu+mBu+Gbh5gOV2kt1B1b+8THamsLft/ekAZXcBx1VS34OtvbXRZxpmVpP8RPgQdPgBPzOrUQ6NIZiWHvAzM6s1Do0h6Ght4sWt3XT3lqtdFTOzQ8qhMQR9D/ht3OomKjOrLQ6NIWif6L7Czaw2OTSGoL3FfYWbWW1yaAxBR9+ZhkPDzGqMQ2MIJjcXaSjU+bZbM6s5Do0hkMQ09+BnZjXIoTFEWQ9+Dg0zqy0OjSHqaG3yNQ0zqzkOjSGa1trIBl/TMLMa49AYoo7WJrZ29bK1q7faVTEzO2QcGkPkHvzMrBY5NIZoV2j4qXAzqyEOjSHqe//UC37brZnVEIfGELmvcDOrRQ6NIRrfWE9LY71fWmhmNaWi0JC0WNJaSeskXTLA9JmSbpW0RtIdkmbkpl0p6aH0OSdX/m1Jq9MyN0uakMo/JmmjpAfS55O5ZT4q6Zfp89ED2/UDN63VfYWbWW0ZNDQkFYBrgNPJ+vs+T1L/fr+vBm6IiHnAZcAVadkzgBOA+cBJwMWSWtMyn42I49MyvwEuyq3vexExP32+ldZ1GPCltJ4TgS9JmjyEfR42HRObfKZhZjWlkjONE4F1EfFERHQDNwFn9ptnLnBbGr49N30usDIieiNiG7AGWAwQEVsAJAkYB8Qg9Xg38JOI2BQRLwM/6VtXtbS3uK9wM6stlYTGEcDTufFnUlneauDsNHwW0CJpSipfLKlZUhtwCnBk30KSvgM8DxwLfD23vg/kmq365q+kHn3rvUDSKkmrNm7cWMEuDk37xKyv8HJ5sLwzMxsbhutC+MXAQkn3AwuB9UApIlYAy4G7gBuBu4FS30IR8XFgOvAo0He941+BWanZ6ifA9ftbmYi4LiI6I6Jz6tSpQ9+rQbS3NNJTCl7e3n3QtmFmNpJUEhrryZ0dADNS2S4R8WxEnB0RC4AvpLLN6fvydG3iNEDA4/2WLZE1eX0gjb8UEX1tPt8CfqvSehxq7ozJzGpNJaFxLzBH0mxJDcC5wLL8DJLaJPWt61JgaSovpGYqJM0D5gErlDkmlQtYAjyWxg/PrXoJ2VkIwC3AuyRNThfA35XKqmZaa1+3r76uYWa1oX6wGSKiV9JFZAfoArA0Ih6WdBmwKiKWAYuAKyQFsBK4MC1eBO7McoEtwPlpfXXA9elOKpFd+/h0WuYPJC0BeoFNwMdSPTZJ+jOyEAO4LCI2HdDeH6COVp9pmFltGTQ0ACJiOdm1iXzZF3PDNwM3D7DcTrI7qPqXl4GT97KtS8nOVgaatpR0FjMSTG1pRPJLC82sdviJ8ANQLNQxZby7fTWz2uHQOEDtrY1+VsPMaoZD4wB1tPqpcDOrHQ6NAzSttcnvnzKzmuHQOEAdrU28uLWbnlK52lUxMzvoHBoHqK8zpg2v+rqGmY19Do0D1D7RfYWbWe1waByg9hb3FW5mtcOhcYB29RXuMw0zqwEOjQN02PgGigXxvJ/VMLMa4NA4QJKY1tLEBp9pmFkNcGgMg46JTX5poZnVBIfGMMheJeLQMLOxz6ExDNpb3Ve4mdUGh8YwaG9tYmtXL1u7eqtdFTOzg8qhMQz6OmNyE5WZjXUOjWEwzc9qmFmNqCg0JC2WtFbSOkmXDDB9pqRbJa2RdIekGblpV0p6KH3OyZV/W9LqtMzNkiak8s9JeiSV3yppZm6ZkqQH0mcZI4TPNMysVgwaGpIKwDXA6WRdt54nqX8XrlcDN0TEPOAy4Iq07BnACcB84CTg4tQvOMBnI+L4tMxvgItS+f1AZyq/Gfjz3HZ2RMT89Fmy33t7kLTvCg1fDDezsa2SM40TgXUR8UREdAM3AWf2m2cucFsavj03fS6wMiJ6I2IbsAZYDBARWwAkCRgHRCq/PSK2p+XvAXadtYxU4xvraWms95mGmY15lYTGEcDTufFnUlneauDsNHwW0CJpSipfLKlZUhtwCnBk30KSvgM8DxwLfH2AbX8C+FFuvEnSKkn3SHr/3ios6YI036qNGzdWsIsHbpqf1TCzGjBcF8IvBhZKuh9YCKwHShGxAlgO3AXcCNwNlPoWioiPA9OBR4Fz8iuUdD7QCVyVK54ZEZ3Ah4GvSTp6oMpExHUR0RkRnVOnTh2mXdy3jol+VsPMxr5KQmM9ubMDsuai9fkZIuLZiDg7IhYAX0hlm9P35ekaxGmAgMf7LVsia/L6QF+ZpHem9SyJiK7cvOvT9xPAHcCCivbyEGhvcV/hZjb2VRIa9wJzJM2W1ACcC+xx55KkNkl967oUWJrKC6mZCknzgHnACmWOSeUClgCPpfEFwLVkgbEht43Jkhr7tgecDDwytN0efu0Ts77CI6LaVTEzO2jqB5shInolXQTcAhSApRHxsKTLgFURsQxYBFwhKYCVwIVp8SJwZ5YLbAHOT+urA65Pd1KJ7NrHp9MyVwETgB+k5X6T7pR6I3CtpDJZ2H05IkZOaLQ00lMKNm3rZsqExmpXx8zsoBg0NAAiYjnZtYl82RdzwzeT3R7bf7mdZHdQ9S8vk50pDLStd+6l/C7guErqWw35224dGmY2VvmJ8GHivsLNrBY4NIZJu58KN7Ma4NAYJtNasiYpd8ZkZmOZQ2OYFAt1tE1o8LMaZjamOTSGUdYZk880zGzscmgMo9lt43lw/SuUyn5Ww8zGJofGMDr9zYez8dUufv7ES9WuipnZQeHQGEbvOHYa4xsKLFv9bLWrYmZ2UDg0htG4hgKnzW3nRw89T3dvudrVMTMbdg6NYbZk/nRe2dHDyscPzSvZzcwOJYfGMHvbMVOZ1FzkX9e4icrMxh6HxjBrqK/j9Dcfzk8eeYEd3aXBFzAzG0UcGgfBkuOns727xH88+kK1q2JmNqwcGgfBibMPo7210XdRmdmY49A4CAp14ozjpvPTtRt5ZUdPtatjZjZsHBoHyZL50+kulbnloeerXRUzs2Hj0DhIjp8xkZlTmn0XlZmNKRWFhqTFktZKWifpkgGmz5R0q6Q1ku6QNCM37UpJD6XPObnyb0tanZa5WdKEVN4o6XtpWz+XNCu3zKWpfK2kdx/Qnh9kknjfvOn8bN2LbHzVb741s7Fh0NCQVACuAU4n67r1PEn9u3C9GrghIuYBlwFXpGXPAE4A5gMnARenfsEBPhsRx6dlfgNclMo/AbwcEccAXwWuTOuaC5wLvAlYDHwz1W3EWjJ/OuWA5Q8+V+2qmJkNi0rONE4E1kXEExHRDdwEnNlvnrnAbWn49tz0ucDKiOiNiG3AGrIDPhGxBUCSgHFA36thzwSuT8M3A6emec4EboqIroh4EliX6jZivb69hWM7WnwXlZmNGZWExhHA07nxZ1JZ3mrg7DR8FtAiaUoqXyypWVIbcApwZN9Ckr4DPA8cC3y9//Yiohd4BZhSYT361nuBpFWSVm3cWN3Xebzv+Onc9+uXeebl7VWth5nZcBiuC+EXAwsl3Q8sBNYDpYhYASwH7gJuBO4Gdj0mHREfB6YDjwLn9F/pUEXEdRHRGRGdU6dOHa7VDsn75k0H4F9Xu4nKzEa/SkJjPbmzA2BGKtslIp6NiLMjYgHwhVS2OX1fHhHzI+I0QMDj/ZYtkTV5faD/9iTVAxOBlyqpx0j0uinNzD9ykpuozGxMqCQ07gXmSJotqYHsYvSy/AyS2iT1retSYGkqL6RmKiTNA+YBK5Q5JpULWAI8lpZfBnw0DX8QuC0iIpWfm+6umg3MAX4xlJ0+1JYcP51Hn9vCug2vVrsqZmYHZNDQSNcVLgJuIWtG+n5EPCzpMklL0myLgLWSHgfagctTeRG4U9IjwHXA+Wl9Aq6X9CDwIHA42V1XAN8GpkhaB3wOuCTV42Hg+8AjwI+BC9NZyoj33nmHUydY5iYqMxvllP0jfuzq7OyMVatWVbsafPhv7+G5V3Zy2+cXkp1cmZmNTJLui4jOgab5ifBDZMnx03nyxW08tH5LtatiZjZkDo1DZPGbOygWxLLVI/7avZnZXjk0DpFJzQ28fc5U/m3Nc5TLY7tJ0MzGLofGIbRk/nSee2Un9z61qdpVMTMbEofGIfTON7bTVKzzm2/NbNRyaBxC4xvreecb21n+4PP0lMrVro6Z2X5zaBxiS46fzqZt3fxs3YvVroqZ2X5zaBxiC98wlZamer9WxMxGJYfGIdZYX2DxmzpY8fAL7OwZFQ+0m5nt4tCogiXzp7O1q5fbH9tQ7aqYme0Xh0YVvPWoKbRNaPBdVGY26jg0qqC+UMcZxx3OrY9u4NWdPdWujplZxRwaVbJk/nS6esv85JEXql0VM7OKOTSq5ITXTeaISeN8F5WZjSoOjSqRxHuPP5z//OWLbNrWXe3qmJlVxKFRRUuOn05vOVj+oDtnMrPRwaFRRXMPb+XoqePdRGVmo0ZFoSFpsaS1ktZJumSA6TMl3SppjaQ7JM3ITbtS0kPpc06u/LtpnQ9JWiqpmMr/t6QH0uchSSVJh6VpT0l6ME2rfnd8B0gSZy04gl88uYmHn32l2tUxMxvUoKEhqQBcA5wOzAXOkzS332xXAzdExDyyvr6vSMueAZwAzAdOAi6W1JqW+S5wLHAcMA74JEBEXBUR8yNiPnAp8NOIyL9L/JQ0fcCuCEebj7x1FhPHFbnqlrXVroqZ2aAqOdM4EVgXEU9ERDdwE3Bmv3nmArel4dtz0+cCKyOiNyK2AWuAxQARsTwS4BfADF7rPODG/dmh0WbiuCKfWXQ0d6zdyD1PvFTt6piZ7VMloXEE8HRu/JlUlrcaODsNnwW0SJqSyhdLapbUBpwCHJlfMDVLfQT4cb/yZrKA+cdccQArJN0n6YK9VVjSBZJWSVq1cePGCnaxuj76O7PoaG3iyh8/RpahZmYj03BdCL8YWCjpfmAhsB4oRcQKYDlwF9kZw91A/7f0fZPsbOTOfuXvA37Wr2nqbRFxAllT2YWS3j5QZSLiuojojIjOqVOnHui+HXRNxQJ/9M453P+bzX7Yz8xGtEpCYz17nh3MSGW7RMSzEXF2RCwAvpDKNqfvy9M1iNMAAY/3LSfpS8BU4HMDbPdc+jVNRcT69L0B+GeyprMx4YO/NYOj2sZz1S1rKbkPcTMboSoJjXuBOZJmS2ogO5gvy88gqU1S37ouBZam8kJqpkLSPGAesCKNfxJ4N3BeRJT7rW8i2RnLD3Nl4yW19A0D7wIe2r/dHbnqC3Vc/O438MsNW/mn/3qm2tUxMxvQoKEREb3ARcAtwKPA9yPiYUmXSVqSZlsErJX0ONAOXJ7Ki8Cdkh4BrgPOT+sD+Js0793pFtov5jZ7FrAiXTzv0w78p6TVZBfO/z0i9rgOMtqd/uYO5s2YyNf+45fua8PMRiSN9QuvnZ2dsWrV6Hmk42frXuS/f+vn/N/3zuUTb5td7eqYWQ2SdN/eHmvwE+EjzMnHtPG2Y9q45vZ1fm26mY04Do0R6I8Xv4FN27r52zufrHZVzMz24NAYgebNmMQZxx3Ot+58ghe3dlW7OmZmuzg0RqjPv+v1dPWW+cZt66pdFTOzXRwaI9RRUyfwu51H8t2f/5qnN22vdnXMzACHxoj2h6fOoU7iqz95fPCZzcwOAYfGCNYxsYmPnTyLf35gPY8+t6Xa1TEzc2iMdJ9eeDQtjfVc7Venm9kI4NAY4SY1N/D7i47m1sc2cO9TmwZfwMzsIHJojAIf/53ZTGtp5Mof+dXpZlZdDo1RYFxDgT84dQ6rfv0ytz22odrVMbMa5tAYJc55y5HMmtLMn//Yr043s+pxaIwSxUIdn3/XG1j7wqssW71+8AXMzA4Ch8YocsZxh/Om6a18ZcXjdPX61elmdujVV7sCVrm6OvF/Fh/L/1j6C278+W/42Ml+dbpZJUrlYGdPiR09JXZ09/vuKdHVUwaCckAEBJG+ISL2KMvmGbiJWNJry/qNd/WW2dFTyuqTq8PO3PCO7tLu+vaUKJX23N5A29k9LfueMr6BH170tv34lSrj0Bhl/tucNt561BS+fts63v76qRw1dUK1q2QjXLkc9JaD3nKZnlLQWyqn8aA8hOtjEdBTLtNbCnpKZXrS+npKWdnu7eyeXurbXgSlcu4TWR1KZShFUCqXKZXZY7788rvqXtq9T/l5ekpBd2951wF3ezoQd/eWB9+xKqgTNDfU01QsMK6hjnHFAuOKBZqKBSaPb2B6Gq6v2x0S+f9i/bMrclNbGg/O4d2hMcpI4k/e80Y+dO1dnPoXP+U9bz6cTy86mjcfMbHaVbN9iMgOaF292QGsu1TOvnvLdPUb7+4ts72nxPau3l0Hve3dabi7xLbuEjvSeF/Z9p5eunt3H8hL5aAnHWRH030ThTpRkKirg4JEfaGO+jpRqBPFQh2FOlFfEPV1or6ubo/hYqGOpqJorK9jXEM944rZQbipoUBzsX73QbmhPn3X0VQs0NxQT0OhDgnqJKTs7CD7F/vu8d3TxD7+ob+HgQ7qjfUFxjVk4VAsaJ9nDSNRRT33SVoM/CVQAL4VEV/uN30mWb/gU4FNZN26PpOmXQmckWb9s4j4Xir/LtAJ9JB13/qpiOiRtIisb/C+ziT+KSIuq6QeAxltPfdVauOrXSz92ZP8/d2/5tWuXv7bnDY+s+gYfvuow0bdH2E1lcuxq7kg32Swc9d4ecCmg/7NGzu6By7f2V2iKwXCgSjUieZigebG7CA3rliguaFAc2N9Vt5QoKG+7yCaHWjrC3UUC7sPuPmDb9/Btm4IfyuSKBb6DtT59WXjfQf6YmH39EJd2l4KhUIhfac6ZN/7bnaxQ2dfPfcNGhqSCsDjwGnAM8C9wHkR8Uhunh8A/xYR10t6B/DxiPiIpDOAPwJOBxqBO4BTI2KLpPcAP0qr+AdgZUT8dQqNiyPivftbj4GM1dDos2VnD39/z69Z+p9P8uLWbha8bhKfWXQMpx47jbq6sf8/YESwvbvEKzt62Ly9h807utmyazj7fmVHD6/s6M7K0vi27l52dJfoGuLBvKm4uylhXMPufzk2pQN4X3ljfYHGYh2NhToa6tOnUEdDfYHG+lxZ/Z7zNDdk/yIen9ad/Ut47P/3tJFhX6FRSfPUicC6iHgirewm4Ewgf7CeC3wuDd8O/EuufGVE9AK9ktYAi4HvR8TyXAV/AcwYhnrUnNamIp9ZdAy/d/JsfnDfM1z701/xP29YxevbJ/D7C4/mfcdPp1gYPTfJ7ewpsWlbN5u2dfPy9vS9rZtN23vSdxpP01/e1kN3ae8H/mJBTBzXwKTmIhPHFTl8YhPHdrQwoSn713pj34G/WMe4huyg35QLg6b63c0YfYHQVF+oiUA2G0gloXEE8HRu/BngpH7zrAbOJms6OgtokTQllX9J0leAZuAU+h3kJRWBjwB/mCt+q6TVwLNkZx0PV1iPvnVeAFwA8LrXva6CXRz9mooFPvLbMznvLUfyb2ue46/v+BWf+/5qvrLicT618Ch+t/NImoqFQ16vUjnYtK2bl7Z18dLWbl7c2sWLW7t5aWsXL25NZduy8Ze2drOjZ+BbiSWYNK7I5PENHNbcwJGHNXP8jElMGl9kcnMDk8YVmdRcpHVckUkpJCY1FxlXLPhf6GbDaLguhF8MfEPSx4CVwHqgFBErJL0FuAvYCNwN9D8qfJPsbOTONP5fwMyI2JqasP4FmLM/lYmI64DrIGueGtIejVL1hTrev+AIlhw/ndvXbuCbd/yKL/7wYf7yP37J771tNsfPmERTse9fznW7mk+aitm/oPd1Ya67t8zm7d1s3pH9q//l7Vmzz8up2Wfz9qwJ6OXt2VnAS1uzM4OBWkDr68Rh4xtom9DIlAkNHNU2ninjGzhsQhYKk8c3cNj4BiY3Z98TxxUp+F/3ZlVXSWisB47Mjc9IZbtExLNkZxpImgB8ICI2p2mXA5enaf9Adl2CNP4lsovnn8qta0tueLmkb0pqq6QetltdnTj1je2849hp/OLJTXzzjl9xVQWvV68TNNbvDpSmYh09peDl7d1s7977A4XFgpjU3MDk5uxf+rOmjKdz1mG0jW+graWRKeOzcGib0EjbhAZam4pu4jEbhSoJjXuBOZJmkx2kzwU+nJ8hHdQ3RUQZuJTsTqq+i9eTIuIlSfOAecCKNO2TwLvJLoyXc+vqAF6IiJB0ItlT6y8Bmwerh72WJE46agonHTWFp17cxoZXu9jZk10A3pnuFtrZW6arf1lPma7e7Lu+oN1NQON3B0NfE9Dk5gaaG9wMZFYLBg2NiOiVdBFwC9mtrksj4mFJlwGrImIZsAi4QlKQNU9dmBYvAnemg8kWsltxe9O0vwF+DdydpvfdWvtB4NOSeoEdwLmR3eI1YD0O+BeoIbPaxjOrbXy1q2Fmo1hFz2mMZmP9llszs+G2r1tuR8+9mGZmVnUODTMzq5hDw8zMKubQMDOzijk0zMysYg4NMzOrmEPDzMwqNuaf05C0kewhwqFoA14cxuqMVv4dMv4dMv4dMmP5d5gZEVMHmjDmQ+NASFq1twdcaol/h4x/h4x/h0yt/g5unjIzs4o5NMzMrGIOjX27rtoVGCH8O2T8O2T8O2Rq8nfwNQ0zM6uYzzTMzKxiDg0zM6uYQ2MAkhZLWitpnaRLql2fapL0lKQHJT0gqWY6JpG0VNIGSQ/lyg6T9BNJv0zfk6tZx0NhL7/Dn0pan/4mHpD0nmrW8VCQdKSk2yU9IulhSX+Yymvub8Kh0U/qovYa4HRgLnCepLnVrVXVnRIR82vsnvS/Axb3K7sEuDUi5gC3pvGx7u947e8A8NX0NzE/IpYf4jpVQy/w+YiYC/w2cGE6LtTc34RD47VOBNZFxBMR0Q3cBJxZ5TrZIRYRK4FN/YrPBK5Pw9cD7z+UdaqGvfwONScinouI/0rDrwKPAkdQg38TDo3XOgJ4Ojf+TCqrVQGskHSfpAuqXZkqa4+I59Lw80B7NStTZRdJWpOar8Z8k0yepFnAAuDn1ODfhEPDBvO2iDiBrLnuQklvr3aFRoLI7lWv1fvV/xo4GpgPPAd8paq1OYQkTQD+EfijiNiSn1YrfxMOjddaDxyZG5+RympSRKxP3xuAfyZrvqtVL0g6HCB9b6hyfaoiIl6IiFJElIG/pUb+JiQVyQLjuxHxT6m45v4mHBqvdS8wR9JsSQ3AucCyKtepKiSNl9TSNwy8C3ho30uNacuAj6bhjwI/rGJdqqbvIJmcRQ38TUgS8G3g0Yj4i9ykmvub8BPhA0i3EH4NKABLI+Ly6taoOiQdRXZ2AVAP/EOt/BaSbgQWkb3++gXgS8C/AN8HXkf2uv3fjYgxfZF4L7/DIrKmqQCeAj6Va9cfkyS9DbgTeBAop+I/IbuuUVt/Ew4NMzOrlJunzMysYg4NMzOrmEPDzMwq5tAwM7OKOTTMzKxiDg0zM6uYQ8PMzCr2/wFfpLaxZl97EgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.0342293, G_loss_U: 1.5985241, G_loss_S: 0.010727854, E_loss_t0: 2.1811955\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.0919445, G_loss_U: 1.7241751, G_loss_S: 0.011440109, E_loss_t0: 2.2466688\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.062292, G_loss_U: 1.7480422, G_loss_S: 0.012715703, E_loss_t0: 2.1192703\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 1.0151469, G_loss_U: 1.6771703, G_loss_S: 0.013443945, E_loss_t0: 2.1893113\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 0.90563846, G_loss_U: 1.5375785, G_loss_S: 0.014173511, E_loss_t0: 2.1799273\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 0.785396, G_loss_U: 1.3760108, G_loss_S: 0.015388824, E_loss_t0: 2.1408267\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 0.70967484, G_loss_U: 1.2527375, G_loss_S: 0.015992464, E_loss_t0: 2.1596076\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 0.6698433, G_loss_U: 1.240892, G_loss_S: 0.01690794, E_loss_t0: 2.221034\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 0.60358953, G_loss_U: 1.4559731, G_loss_S: 0.018506264, E_loss_t0: 2.1092417\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 0.48670816, G_loss_U: 1.9767333, G_loss_S: 0.021636581, E_loss_t0: 1.8861767\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 0.35234216, G_loss_U: 2.5464518, G_loss_S: 0.023440124, E_loss_t0: 1.659985\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 0.2910264, G_loss_U: 2.9916458, G_loss_S: 0.022709848, E_loss_t0: 1.7441691\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step: 0/2, D_loss: 0.23880857, G_loss_U: 3.334999, G_loss_S: 0.025147358, E_loss_t0: 1.8970407\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-13-105f45280b4f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mGenerator\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mEmbedder\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mSupervisor\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mRecovery\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mDiscriminator\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtest\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtest_recovery\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcheckpoints\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mTimeGAN\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mparameters\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-12-f6d73f326eec>\u001b[0m in \u001b[0;36mTimeGAN\u001b[1;34m(data, parameters)\u001b[0m\n\u001b[0;32m    288\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    289\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 290\u001b[1;33m       \u001b[0mrandom_test\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mrandom_generator\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mextract_time\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mextract_time\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    291\u001b[0m       \u001b[0mtest_sample\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mGenerator\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtensor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrandom_generator\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mextract_time\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mextract_time\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    292\u001b[0m       \u001b[0mtest_sample\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_sample\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mseq_len\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mhidden_dim\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-2-d9808afcedea>\u001b[0m in \u001b[0;36mextract_time\u001b[1;34m(data)\u001b[0m\n\u001b[0;32m     12\u001b[0m   \u001b[0mmax_seq_len\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     13\u001b[0m   \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 14\u001b[1;33m     \u001b[0mmax_seq_len\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmax_seq_len\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     15\u001b[0m     \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     16\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "Generator, Embedder, Supervisor, Recovery, Discriminator, test, test_recovery, checkpoints = TimeGAN(data, parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils import extract_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_test = random_generator(12800, dim, extract_time(data)[0], extract_time(data)[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.tensor(random_test).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oben wird die selbe anzahl an Noise-Daten wie in den echten Daten erzeugt, und dann in den Generator geworfen; Das wird dann wiederrum in die Recovery gegeben, und darauf dann die Visualisierung gemacht"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "test = Generator(random_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = torch.reshape(test, (12800, seq_len, 40))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_recovery = Recovery(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_recovery = torch.reshape(test_recovery[0], (12800, seq_len, dim))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_recovery.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Time-series Generative Adversarial Networks (TimeGAN) Codebase.\n",
    "Reference: Jinsung Yoon, Daniel Jarrett, Mihaela van der Schaar, \n",
    "\"Time-series Generative Adversarial Networks,\" \n",
    "Neural Information Processing Systems (NeurIPS), 2019.\n",
    "Paper link: https://papers.nips.cc/paper/8789-time-series-generative-adversarial-networks\n",
    "Last updated Date: April 24th 2020\n",
    "Code author: Jinsung Yoon (jsyoon0823@gmail.com)\n",
    "-----------------------------\n",
    "visualization_metrics.py\n",
    "Note: Use PCA or tSNE for generated and original data visualization\n",
    "\"\"\"\n",
    "\n",
    "# Necessary packages\n",
    "from sklearn.manifold import TSNE\n",
    "from sklearn.decomposition import PCA\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "   \n",
    "def visualization (ori_data, generated_data, analysis):\n",
    "  \"\"\"Using PCA or tSNE for generated and original data visualization.\n",
    "  \n",
    "  Args:\n",
    "    - ori_data: original data\n",
    "    - generated_data: generated synthetic data\n",
    "    - analysis: tsne or pca\n",
    "  \"\"\"  \n",
    "  # Analysis sample size (for faster computation)\n",
    "  anal_sample_no = min([1000, len(ori_data)])\n",
    "  idx = np.random.permutation(len(ori_data))[:anal_sample_no]\n",
    "    \n",
    "  # Data preprocessing\n",
    "  ori_data = np.asarray(ori_data)\n",
    "  generated_data = np.asarray(generated_data)  \n",
    "  \n",
    "  ori_data = ori_data[idx]\n",
    "  generated_data = generated_data[idx]\n",
    "  \n",
    "  no, seq_len, dim = ori_data.shape  \n",
    "  \n",
    "  for i in range(anal_sample_no):\n",
    "    if (i == 0):\n",
    "      prep_data = np.reshape(np.mean(ori_data[0,:,:], 1), [1,seq_len])\n",
    "      prep_data_hat = np.reshape(np.mean(generated_data[0,:,:],1), [1,seq_len])\n",
    "    else:\n",
    "      prep_data = np.concatenate((prep_data, \n",
    "                                  np.reshape(np.mean(ori_data[i,:,:],1), [1,seq_len])))\n",
    "      prep_data_hat = np.concatenate((prep_data_hat, \n",
    "                                      np.reshape(np.mean(generated_data[i,:,:],1), [1,seq_len])))\n",
    "    \n",
    "  # Visualization parameter        \n",
    "  colors = [\"red\" for i in range(anal_sample_no)] + [\"blue\" for i in range(anal_sample_no)]    \n",
    "    \n",
    "  if analysis == 'pca':\n",
    "    # PCA Analysis\n",
    "    pca = PCA(n_components = 2)\n",
    "    pca.fit(prep_data)\n",
    "    pca_results = pca.transform(prep_data)\n",
    "    pca_hat_results = pca.transform(prep_data_hat)\n",
    "    \n",
    "    # Plotting\n",
    "    f, ax = plt.subplots(1)    \n",
    "    plt.scatter(pca_results[:,0], pca_results[:,1],\n",
    "                c = colors[:anal_sample_no], alpha = 0.2, label = \"Original\")\n",
    "    plt.scatter(pca_hat_results[:,0], pca_hat_results[:,1], \n",
    "                c = colors[anal_sample_no:], alpha = 0.2, label = \"Synthetic\")\n",
    "  \n",
    "    ax.legend()  \n",
    "    plt.title('PCA plot')\n",
    "    plt.xlabel('x-pca')\n",
    "    plt.ylabel('y_pca')\n",
    "    plt.show()\n",
    "    \n",
    "  elif analysis == 'tsne':\n",
    "    \n",
    "    # Do t-SNE Analysis together       \n",
    "    prep_data_final = np.concatenate((prep_data, prep_data_hat), axis = 0)\n",
    "    \n",
    "    # TSNE anlaysis\n",
    "    tsne = TSNE(n_components = 2, verbose = 1, perplexity = 40, n_iter = 300)\n",
    "    tsne_results = tsne.fit_transform(prep_data_final)\n",
    "      \n",
    "    # Plotting\n",
    "    f, ax = plt.subplots(1)\n",
    "      \n",
    "    plt.scatter(tsne_results[:anal_sample_no,0], tsne_results[:anal_sample_no,1], \n",
    "                c = colors[:anal_sample_no], alpha = 0.2, label = \"Original\")\n",
    "    plt.scatter(tsne_results[anal_sample_no:,0], tsne_results[anal_sample_no:,1], \n",
    "                c = colors[anal_sample_no:], alpha = 0.2, label = \"Synthetic\")\n",
    "  \n",
    "    ax.legend()\n",
    "      \n",
    "    plt.title('t-SNE plot')\n",
    "    plt.xlabel('x-tsne')\n",
    "    plt.ylabel('y_tsne')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "visualization(data, test_recovery.detach().numpy(), 'tsne')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "visualization(data, test_recovery.detach().numpy(), 'pca')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax1 = plt.plot(test_recovery[0].detach().numpy())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0,test_recovery.shape[0]):\n",
    "    \n",
    "    if i % 100 == 0:\n",
    "        fig, ax = plt.subplots()\n",
    "        ax1 = plt.plot(test_recovery[i].detach().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_recovery.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax1 = plt.plot(data[0].detach().numpy())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_recovery[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_recovery[5000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_recovery[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax1 = plt.plot(data[0].detach().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "\n",
    "ax1 = plt.plot(data[5000].detach().numpy())"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "trainings_loops.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "torch",
   "language": "python",
   "name": "torch"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.11"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
